@atomist/sdm

@atomist/sdm

Version 2.1.6
Published 3 years ago
10.2 MB
65 dependencies
Apache-2.0 license

Install

npm i @atomist/sdm

yarn add @atomist/sdm

pnpm add @atomist/sdm

Overview

Atomist Software Delivery Machine SDK

Index

Variables

variable AddressNoChannels

const AddressNoChannels: AddressChannels;

Throw away contents. Use when we know that there can be no linked channels.

variable and

const and: (...pushTests: PushTestOrProjectPredicate[]) => PushTest;

Wrap all these PushTests or ProjectPredicates in a single PushTest AND: Return true if all are satisfied

variable AnyPush

const AnyPush: PushTest;

Match on any push
Parameter p

variable ApproveGoalIfErrorComments

const ApproveGoalIfErrorComments: ReviewListenerRegistration;

Listener that requires approval on the code inspection if the review has any error comments.

variable ApproveGoalIfWarnComments

const ApproveGoalIfWarnComments: ReviewListenerRegistration;

Listener that requires approval on the code inspection if the review has any warn comments.

variable AtomistContinuationMimeType

const AtomistContinuationMimeType: string;

variable AutofixProgressReporter

const AutofixProgressReporter: ReportProgress;

Default ReportProgress for running autofixes

variable AutofixProgressTests

const AutofixProgressTests: ProgressTest[];

variable BaseContext

const BaseContext: string;

variable CFamilyLanguageSourceFiles

const CFamilyLanguageSourceFiles: string;

Glob patterns for C family languages

variable CloningProjectLoader

const CloningProjectLoader: ProjectLoader;

Non caching ProjectLoader that uses a separate clone for each project accessed

variable createEphemeralProgressLog

const createEphemeralProgressLog: ProgressLogFactory;

variable DefaultCancelOptions

const DefaultCancelOptions: CancelOptions;

variable DefaultExtractAuthor

const DefaultExtractAuthor: ExtractAuthor;

variable DefaultGoalNameGenerator

const DefaultGoalNameGenerator: SourceLocationGoalNameGenerator;

variable DefaultMockOptions

const DefaultMockOptions: MockOptions;

Default mock options to be merged into custom options provided on configuration.sdm.mock

variable DefaultPredicateMappingCostAnalyzer

const DefaultPredicateMappingCostAnalyzer: PredicateMappingCostAnalyzer<any>;

Estimate cost by looking at code to see if it goes through a project
Parameter pm
{any}

variable DefaultQueueOptions

const DefaultQueueOptions: QueueOptions;

variable DoNotSetAnyGoals

const DoNotSetAnyGoals: Goals;

Constant to indicate we should never match. {any}

variable DoNotSetAnyGoalsAndLock

const DoNotSetAnyGoalsAndLock: Goals;

Should be used in additive goal setting when no more goals should be scheduled.

variable DryRunParameter

const DryRunParameter: any;

variable FailGoalIfErrorComments

const FailGoalIfErrorComments: ReviewListenerRegistration;

Listener that fails the code inspection if the review has any error comments.

variable FailGoalIfWarnComments

const FailGoalIfWarnComments: ReviewListenerRegistration;

Listener that fails the code inspection if the review has any warn comments.

variable FromAtomist

const FromAtomist: PushTest;

Is this a push originated by Atomist? Note that we can't look at the committer, as if a user invoked a command handler, their credentials will be used
Parameter p
{boolean}

variable GeneratorTag

const GeneratorTag: string;

variable GitBranchRegExp

const GitBranchRegExp: BaseParameter;

variable GitHubNameRegExp

const GitHubNameRegExp: BaseParameter;

variable githubTeamVoter

const githubTeamVoter: (team?: string) => GoalApprovalRequestVoter;

Deprecated
since 1.0.0 use gitHubTeamVoter instead

variable GitShaRegExp

const GitShaRegExp: BaseParameter;

variable GoalSetGoalCompletionListener

const GoalSetGoalCompletionListener: Function1<I, Promise<R>>;

Update the state of the SdmGoalSet as the goals progress
Parameter gcl

variable HasTravisFile

const HasTravisFile: PredicatePushTest;

Does this project use Travis?

variable Immaterial

const Immaterial: GoalWithFulfillment;

Goal that should be scheduled for immaterial changes. Uses a no-op goalExecutor.

variable ImmaterialGoals

const ImmaterialGoals: Goals;

Goals instance for Immaterial changes

variable IndependentOfEnvironment

const IndependentOfEnvironment: GoalEnvironment;

variable InspectionTag

const InspectionTag: string;

variable IsDeployEnabled

const IsDeployEnabled: PushTest;

Is repo enabled for deployment
Parameter pi

variable IsPushToBranchWithPullRequest

const IsPushToBranchWithPullRequest: PushTest;

Is this push to a non-default branch that has an open pull request?

variable JobDescriptionParameter

const JobDescriptionParameter: any;

variable JobNameParameter

const JobNameParameter: any;

variable JobRequiredParameter

const JobRequiredParameter: any;

variable Locking

const Locking: Goal;

variable LogSuppressor

const LogSuppressor: InterpretLog<any>;

Use when we don't want to report the log to the user under any circumstances {InterpretedLog}

variable MsgIdParameter

const MsgIdParameter: any;

variable NamedSeedRepo

const NamedSeedRepo: PushTest;

Is this a seed repo, based on the naming convention that such repos have "-seed" in their name
Parameter pi

variable NonEmpty

const NonEmpty: PredicatePushTest;

PushTest that returns true if project is non empty {PredicatePushTest}

variable NoOpExtractAuthor

const NoOpExtractAuthor: ExtractAuthor;

variable NoParameterPrompt

const NoParameterPrompt: ParameterPrompt<any>;

No-op NoParameterPrompt implementation that never prompts for new parameters

variable NoPreferenceStore

const NoPreferenceStore: PreferenceStore;

NoOp PreferenceStore implementation useful for situations in which the SDM does not support preferences or tests.

variable NoProgressReport

const NoProgressReport: ReportProgress;

Don't report any progress

variable not

const not: <F>(t: PredicateMapping<F>) => PredicateMapping<F>;

Return the opposite of this push test

variable or

const or: (...pushTests: PushTestOrProjectPredicate[]) => PushTest;

Wrap all these PushTests or ProjectPredicates in a single PushTest OR: Return true if any is satisfied

variable ProductionEnvironment

const ProductionEnvironment: GoalEnvironment;

variable ProjectDisposalEnvironment

const ProjectDisposalEnvironment: GoalEnvironment;

variable SemVerRegExp

const SemVerRegExp: BaseParameter;

Validation pattern for semantic versions {{displayName: string; description: string; pattern: RegExp; validInput: string; minLength: number; maxLength: number}}

variable ServiceRegistrationGoalDataKey

const ServiceRegistrationGoalDataKey: string;

Key under which services can be found in goal data.

variable StagingEnvironment

const StagingEnvironment: GoalEnvironment;

variable SuccessIsReturn0ErrorFinder

const SuccessIsReturn0ErrorFinder: ErrorFinder;

Default ErrorFinder that regards everything but a return code of 0 as failure.
Parameter code
process exit status true if exit status is not zero

variable ToDefaultBranch

const ToDefaultBranch: PushTest;

variable TransformTag

const TransformTag: string;

variable UnanimousGoalApprovalRequestVoteDecisionManager

const UnanimousGoalApprovalRequestVoteDecisionManager: GoalApprovalRequestVoteDecisionManager;

Default GoalApprovalRequestVoteDecisionManager that decides unanimously on votes. One denied vote will deny the approval request; all granted votes with grant the request. All other votes with result in an abstained approval request.
Parameter votes

Functions

function actionableButton

actionableButton: <T extends ParameterType>(
    buttonSpec: ButtonSpecification,
    commandHandlerRegistration: CommandRegistration<T> | string,
    parameters?: ParameterType
) => Action;

Create an actionable button invoking the given command
Parameter buttonSpec
Parameter commandHandlerRegistration
command registration or command name
Parameter parameters
parameters to the command

function actionableMenu

actionableMenu: <T extends ParameterType>(
    menuSpec: MenuSpecification,
    commandHandlerRegistration: CommandRegistration<T> | string,
    parameterName: string,
    parameters?: ParameterType
) => Action;

Create an actionable menu invoking the given command
Parameter menuSpec
Parameter commandHandlerRegistration
command registration or command name
Parameter parameterName
name of the parameter to bind the menu to
Parameter parameters
parameters to the command

function adaptHandleCommand

adaptHandleCommand: (
    maker: Maker<HandleCommand<any>>
) => CommandHandlerRegistration;

Convert an decorator-style HandleCommand to a SDM-style CommandHandlerRegistration

function addMappedParameters

addMappedParameters: (
    p: NamedMappedParameter,
    ...more: NamedMappedParameter[]
) => ParametersBuilder;

Declare a new mapped parameter for the given command {ParametersBuilder}

function addParameters

addParameters: (
    p: NamedParameter,
    ...more: NamedParameter[]
) => ParametersBuilder;

Declare a new parameter for the given command {ParametersBuilder}

function addressChannelsFor

addressChannelsFor: (
    hasChannels: HasChannels,
    ctx: HandlerContext
) => AddressChannels;

Address the chat channels associated with this object. Typically used to address channels associated with a repo.
Parameter hasChannels
Parameter ctx
{AddressChannels}

function addressChannelsProgressLog

addressChannelsProgressLog: (
    name: string,
    hasChannels: HasChannels,
    ctx: HandlerContext
) => ProgressLog;

Stream the ProgressLog output to any channels associated with the current model element (such a repo) in Slack or elswhere.
Parameter name
name for the log. Should relate to the activity we're logging
Parameter hasChannels
Parameter ctx
{ProgressLog}

function addressDestinations

addressDestinations: (
    ctx: HandlerContext,
    ...destinations: Destination[]
) => AddressChannels;

function addSecrets

addSecrets: (s: NamedSecret, ...more: NamedSecret[]) => ParametersBuilder;

Declare a new secret parameter for the given command {ParametersBuilder}

function addValues

addValues: (s: NamedValue, ...more: NamedValue[]) => ParametersBuilder;

Declare a new configuration value parameter for the given command {ParametersBuilder}

function afterListener

afterListener: (listener: PrepareForGoalExecution) => GoalProjectListener;

Convenience function that takes a PrepareForGoalExecution and invokes it for after goal project events.
Parameter listener

function all

all: <F>(
    predicates: Array<PredicateMapping<F>>,
    analyzer?: PredicateMappingCostAnalyzer<F>
) => PredicateMapping<F>;

Wrap all these predicates in a single predicate AND: Return true if all are satisfied
Parameter predicates
Parameter analyzer
analyzer to use for performance optimization {PredicateMapping}

function allOf

allOf: <F>(
    pred1: PredicateMappingTerm<F>,
    ...preds: Array<PredicateMappingTerm<F>>
) => PredicateMapping<F>;

Predicate mapping DSL method. Allows use of booleans and functions returning boolean in predicate expressions
Parameter pred1
Parameter preds

function allPredicatesSatisfied

allPredicatesSatisfied: (...predicates: ProjectPredicate[]) => ProjectPredicate;

Wrap all these ProjectPredicates in a single ProjectPredicate AND: Return true if all are satisfied
Parameter predicates
{ProjectPredicate}

function allReposInTeam

allReposInTeam: (rrr: RepoRefResolver) => RepoFinder;

Use a GraphQL query to find all repos for the current team
Parameter rrr
RepoRefResolver used to find RepoRef from GraphQL result

function allSatisfied

allSatisfied: (...pushTests: PushTestOrProjectPredicate[]) => PushTest;

Wrap all these PushTests or ProjectPredicates in a single PushTest AND: Return true if all are satisfied
Parameter pushTests
{PushTest}

function announceTransformResults

announceTransformResults: (
    trs: TransformResult[],
    cli: CommandListenerInvocation
) => Promise<void>;

This is a useful function to pass to CodeTransformRegistration.onTransformResults. It sends a message per repository describing any errors that occurred while saving the transforms, and also where the transform was applied. It gives you the branch name.
Parameter trs
results of transforms
Parameter cli
original command invocation

function any

any: <F>(
    predicates: Array<PredicateMapping<F>>,
    analyzer?: PredicateMappingCostAnalyzer<F>
) => PredicateMapping<F>;

Wrap all these predicates in a single predicate OR: Return true if any is satisfied
Parameter predicates
Parameter analyzer
analyzer to use for performance optimization {PredicateMapping}

function anyFileChanged

anyFileChanged: (
    options: MaterialChangeOptions,
    changedFiles: string[]
) => boolean;

function anyFileChangedSuchThat

anyFileChangedSuchThat: (
    changedFilePaths: string[],
    test: (path: string) => boolean
) => boolean;

Does a file satisfying this text exist within the set of changed files?
Parameter changedFilePaths
Parameter test
test for the file change {boolean}

function anyFileChangedWithExtension

anyFileChangedWithExtension: (
    changedFilePaths: string[],
    extensions: string[]
) => boolean;

function anyPredicateSatisfied

anyPredicateSatisfied: (...predicates: ProjectPredicate[]) => ProjectPredicate;

Wrap all these ProjectPredicates in a single ProjectPredicate OR: Return true if any is satisfied
Parameter predicates
{ProjectPredicate}

function anySatisfied

anySatisfied: (...pushTests: PushTestOrProjectPredicate[]) => PushTest;

Wrap all these PushTests or ProjectPredicates in a single PushTest OR: Return true if any is satisfied
Parameter pushTests
{PushTest}

function appendOrCreateFileContent

appendOrCreateFileContent: (
    command: AppendOrCreateCommand
) => SimpleProjectEditor;

Return an editor to append the given content to the end of the file at the specified path, creating the file with only this content if it doesn't exist. Adds no whitespace.
Parameter command
command {SimpleProjectEditor}

function attachFacts

attachFacts: <FACT, F extends SdmContext = PushListenerInvocation>(
    compute: (f: F) => Promise<FACT>
) => GoalContribution<F>;

Enrich the invocation, attaching some facts. The returned object will be merged with any facts already on the invocation.
Parameter compute
additional facts. {GoalContribution}

function beforeListener

beforeListener: (listener: PrepareForGoalExecution) => GoalProjectListener;

Convenience function that takes a PrepareForGoalExecution and invokes it for before goal project events.
Parameter listener

function branchAwareCodeTransform

branchAwareCodeTransform: (
    codeTransformRegistration: CodeTransformRegistration<any>,
    sdm: SoftwareDeliveryMachine
) => CommandHandlerRegistration<RepoTargetingParameters>;

Wrap a CodeTransform to determine the target branch of the transform.
If the target branch, as expressed by the CodeTransformRegistration.transformPresentation, already exists, the wrapped CodeTransform will run against that branch instead of the requested branch.
Parameter codeTransformRegistration
Parameter sdm

function cacheKey

cacheKey: (params: ProjectLoadingParameters) => string;

Compute a cache key from the given ProjectLoadingParameters.
In this context undefined and false are functionally equivalent, so undefined values are coerced to false.
Parameter id
{any}

function cancelableGoal

cancelableGoal: (
    sdmGoal: SdmGoalEvent,
    configuration: Configuration
) => Promise<boolean>;

Can goal be canceled

function chattyDryRunAwareEditor

chattyDryRunAwareEditor: (
    ctr: CodeTransformRegistration<any>,
    underlyingEditor: AnyProjectEditor
) => ProjectEditor;

Wrap this editor to make it chatty, so it responds to Slack if there's nothing to do. It also honors the dryRun parameter flag to just capture the git diff and send it back to Slack instead of pushing changes to Git.

function chooseAndSetGoals

chooseAndSetGoals: (
    rules: ChooseAndSetGoalsRules,
    parameters: {
        context: HandlerContext;
        credentials: ProjectOperationCredentials;
        push: PushFields.Fragment;
    }
) => Promise<Goals | undefined>;

Choose and set goals for this push
Parameter rules
: configuration for handling incoming pushes
Parameter parameters
details of incoming request {Promise<Goals | undefined>}

function codeInspectionRegistrationToCommand

codeInspectionRegistrationToCommand: <R>(
    sdm: MachineOrMachineOptions,
    cir: CodeInspectionRegistration<R, any>
) => Maker<HandleCommand>;

function codeTransformRegistrationToCommand

codeTransformRegistrationToCommand: (
    sdm: MachineOrMachineOptions,
    ctr: CodeTransformRegistration<any>
) => Maker<HandleCommand>;

function commandHandlerRegistrationToCommand

commandHandlerRegistrationToCommand: <P = NoParameters>(
    sdm: MachineOrMachineOptions,
    c: CommandHandlerRegistration<P>
) => Maker<HandleCommand<P>>;

function commandRequestParameterPromptFactory

commandRequestParameterPromptFactory: <T>(
    ctx: HandlerContext
) => ParameterPrompt<T>;

Default ParameterPromptFactory that uses the WebSocket connection to send parameter prompts to the backend.
Parameter ctx

function computeShaOf

computeShaOf: (s: string) => string;

Compute the sha of the given string
Parameter s
{string}

function computeStartingPoint

computeStartingPoint: <P extends SeedDrivenGeneratorParameters>(
    params: P,
    ctx: HandlerContext,
    repoLoader: RepoLoader,
    details: GeneratorCommandDetails<any>,
    startingPoint: StartingPoint<P>,
    cr: CommandRegistration<P>,
    sdmo: SoftwareDeliveryMachineOptions
) => Promise<Project>;

Retrieve a seed. Set the seed location on the parameters if possible and necessary.

function confirmEditedness

confirmEditedness: (editResult: EditResult) => Promise<EditResult>;

Try to work out whether a project was edited, looking at git status if we can't find out from the edit result
Parameter editResult
{Promise}

function constructGoalSet

constructGoalSet: (
    ctx: HandlerContext,
    goalSetId: string,
    goalSet: string,
    sdmGoals: SdmGoalMessage[],
    tags: GoalSetTag[],
    push: OnPushToAnyBranch.Push
) => SdmGoalSetMessage;

function constructProvenance

constructProvenance: (ctx: HandlerContext) => SdmProvenance;

function constructSdmGoal

constructSdmGoal: (
    ctx: HandlerContext,
    parameters: {
        goalSet: string;
        goalSetId: string;
        goal: Goal;
        state: SdmGoalState;
        id: RemoteRepoRef;
        providerId: string;
        url?: string;
        fulfillment?: SdmGoalFulfillment;
    }
) => SdmGoalMessage;

function constructSdmGoalImplementation

constructSdmGoalImplementation: (
    gi: GoalImplementation,
    registration: string
) => SdmGoalFulfillment;

function copyFileFromUrl

copyFileFromUrl: (url: string, path: string) => CodeTransform;

Add the downloaded content to the given project
Parameter url
url of the content. Must be publicly accessible
Parameter path

function copyFiles

copyFiles: (
    donorProject: Project,
    fileMappings: Array<FileMapping | string>
) => CodeTransform;

function copyFilesFrom

copyFilesFrom: (
    donorProjectId: RemoteRepoRef,
    fileMappings: Array<FileMapping | string>,
    credentials: ProjectOperationCredentials
) => CodeTransform;

Take the specified files from the donor project
Parameter donorProjectId
Parameter fileMappings
Parameter credentials
{SimpleProjectEditor}

function createCommand

createCommand: <PARAMS = NoParameters>(
    sdm: MachineOrMachineOptions,
    commandMaker: (sdm: MachineOrMachineOptions) => OnCommand<PARAMS>,
    name: string,
    paramsMaker?: Maker<PARAMS>,
    details?: CommandDetails
) => HandleCommand<PARAMS>;

Wrap a function in a command handler, allowing use of custom parameters. Targeting (targets property) is handled automatically if the parameters do not implement TargetsParams
Parameter sdm
machine or options
Parameter commandMaker
function to create command function
Parameter name
command name
Parameter paramsMaker
parameters factory, typically the name of a class with a no arg constructor
Parameter details
optional details to customize behavior Add intent "edit "

function createJob

createJob: <T extends ParameterType>(
    details: JobDetails<T>,
    ctx: HandlerContext
) => Promise<{ id: string }>;

Create a Job in the backend with the provided name and tasks
A job can execute any registered command in the same or other connected SDM:
command: name of the CommandRegistration or the registration instance itself registration: optional name of the SDM this job should be send to; defaults to the current SDM parameters: Record type with all required parameters for this command name: optional name of the job description: optional description of the job used to display to the user in chat or web

function createPredicatedGoal

createPredicatedGoal: (
    egi: EssentialGoalInfo,
    goalExecutor: ExecuteGoal,
    w: WaitRules
) => Goal;

Create a goal from the given executor, waiting until a condition is satisfied, with a given timeout.
Parameter egi
Parameter goalExecutor
Parameter w
rules for waiting {Goal}

function createPredicatedGoalExecutor

createPredicatedGoalExecutor: (
    uniqueName: string,
    goalExecutor: ExecuteGoal,
    w: WaitRules,
    unref?: boolean
) => ExecuteGoal;

Wrap provided ExecuteGoal instance with WaitRules processing
Parameter uniqueName
Parameter goalExecutor
Parameter w
rules for waiting {ExecuteGoal}

function createPushImpactListenerInvocation

createPushImpactListenerInvocation: (
    goalInvocation: GoalInvocation,
    project: GitProject
) => Promise<PushImpactListenerInvocation>;

Create a PushImpactListenerInvocation from the given context. Includes both the complete project and the changed files.
Parameter goalInvocation
Parameter project
{Promise}

function createRetryingGoalExecutor

createRetryingGoalExecutor: (
    uniqueName: string,
    goalExecutor: ExecuteGoal,
    retry: RetryOptions
) => ExecuteGoal;

function createSkillContext

createSkillContext: <C extends Record<string, any> = any>(
    ctx: HandlerContext
) => SkillContext<C>;

Helper function to create a SkillContext instance from the passed in HandlerContext

function decode

decode: (coded: string) => string;

Decode the given Base 64 string
Parameter coded
{string}

function descriptionFromState

descriptionFromState: (
    goal: Goal,
    state: SdmGoalState,
    goalEvent?: SdmGoalEvent
) => string;

function determineGoals

determineGoals: (
    rules: {
        projectLoader: ProjectLoader;
        repoRefResolver: RepoRefResolver;
        goalSetter: GoalSetter;
        implementationMapping: GoalImplementationMapper;
        enrichGoal: EnrichGoal;
        tagGoalSet?: TagGoalSet;
    },
    circumstances: {
        credentials: ProjectOperationCredentials;
        id: RemoteRepoRef;
        context: HandlerContext;
        configuration: Configuration;
        push: PushFields.Fragment;
        addressChannels: AddressChannels;
        preferences?: PreferenceStore;
        goalSetId: string;
    }
) => Promise<{
    determinedGoals: Goals | undefined;
    goalsToSave: SdmGoalMessage[];
    tags: GoalSetTag[];
}>;

function doWithProject

doWithProject: (
    action: (pa: ProjectAwareGoalInvocation) => Promise<void | ExecuteGoalResult>,
    cloneOptions?: CloneOptions & { readOnly: boolean }
) => ExecuteGoal;

Convenience method to create goal implementations that require a local clone of the project.
Parameter action
Parameter cloneOptions
Returns
{ExecuteGoal}

function doWithRepos

doWithRepos: (
    sdm: SoftwareDeliveryMachine,
    i: SdmContext,
    action: WithLoadedProject<any>
) => Promise<any>;

Perform an action on all accessible repos in parallel up to a configurable max concurrency limit. This is normally readonly. If you want to perform an update, use a CodeTransform.
Parameter sdm
Parameter i
Parameter action
{Promise}

function encode

encode: (str: string) => string;

Base 64 encode the given string
Parameter str
{string}

function enrichGoalSetters

enrichGoalSetters: <F extends SdmContext = StatefulPushListenerInvocation<any>>(
    mapping: GoalContribution<F>,
    contributor: GoalContribution<F>,
    ...contributors: Array<GoalContribution<F>>
) => Mapping<F, Goals> & GoalSettingStructure<F, Goals>;

Enrich the given push mapping with our own contributions
Parameter mapping
Parameter contributor
Parameter contributors
{Mapping<F extends SdmContext, Goals>}

function environmentFromGoal

environmentFromGoal: (goal: Goal) => string;

function eventHandlerRegistrationToEvent

eventHandlerRegistrationToEvent: (
    sdm: MachineOrMachineOptions,
    e: EventHandlerRegistration<any, any>
) => Maker<HandleEvent>;

function executeAutofixes

executeAutofixes: (
    registrations: AutofixRegistration[],
    transformPresentation?: TransformPresentation<GoalInvocationParameters>,
    extractAuthor?: ExtractAuthor
) => ExecuteGoal;

Execute autofixes against this push Throw an error on failure
Parameter registrations
ExecuteGoal

function executeAutoInspects

executeAutoInspects: (options: AutoInspectOptions) => ExecuteGoal;

Execute auto inspections and route or react to review results using review listeners
Parameter autoInspectRegistrations
Parameter reviewListeners
listeners to respond to reviews {ExecuteGoal}

function executeCancelGoalSets

executeCancelGoalSets: (options: CancelOptions, name: string) => ExecuteGoal;

Cancel any pending goals that are on the previous commit of the goal's branch
Parameter options
Parameter name

function executeGoal

executeGoal: (
    rules: {
        projectLoader: ProjectLoader;
        goalExecutionListeners: GoalExecutionListener[];
    },
    implementation: GoalImplementation,
    gi: GoalInvocation
) => Promise<ExecuteGoalResult>;

Central function to execute a goal with progress logging

function executeHook

executeHook: (
    rules: { projectLoader: ProjectLoader },
    goalInvocation: GoalInvocation,
    sdmGoal: SdmGoalEvent,
    stage: 'post' | 'pre'
) => Promise<HandlerResult>;

function executePushImpact

executePushImpact: (
    registrations: PushImpactListenerRegisterable[]
) => ExecuteGoal;

Execute arbitrary code reactions against a codebase
Parameter registrations
{ExecuteGoal}

function executeSendMessageToSlack

executeSendMessageToSlack: (msg: string | SlackMessage) => ExecuteGoal;

* Execute a goal by sending a message to the linked Slack channels
Parameter msg
{ExecuteGoal}

function fakeCommandListenerInvocation

fakeCommandListenerInvocation: <P>(
    opts?: Partial<CommandListenerInvocation<P>>
) => CommandListenerInvocation<P>;

function fakeContext

fakeContext: (workspaceId?: string) => HandlerContext & AutomationContextAware;

Convenient function to allow creating fake contexts. Useful for testing
Parameter workspaceId
{any}

function fakeGoalInvocation

fakeGoalInvocation: (
    id: RemoteRepoRef,
    options?: SoftwareDeliveryMachineOptions
) => GoalInvocation;

Useful testing support
Parameter id
{GoalInvocation}

function fakePush

fakePush: (
    project?: Project,
    pli?: Partial<PushListenerInvocation>
) => PushListenerInvocation;

Used for testing
Parameter project
Parameter pli
{PushListenerInvocation}

function fetchCommitForSdmGoal

fetchCommitForSdmGoal: (
    ctx: HandlerContext,
    goal: SdmGoalFields.Fragment & SdmGoalRepo.Fragment
) => Promise<CommitForSdmGoal.Commit>;

function fetchGoalsForCommit

fetchGoalsForCommit: (
    ctx: HandlerContext,
    id: RemoteRepoRef,
    providerId: string,
    goalSetId?: string
) => Promise<SdmGoalEvent[]>;

function fetchGoalsFromPush

fetchGoalsFromPush: (sdmGoal: SdmGoalEvent) => SdmGoalEvent[];

function fileContent

fileContent: (
    token: string,
    rr: GitHubRepoRef,
    path: string
) => Promise<string | undefined>;

function filesChangedSince

filesChangedSince: (
    project: GitProject,
    push: PushFields.Fragment
) => Promise<string[] | undefined>;

Use git to list the files changed since the given sha or undefined if we cannot determine it
Parameter project
Parameter push
{Promise<string[]>}

function filteredView

filteredView: <P extends Project = Project>(
    p: Project,
    filter: (path: string) => boolean
) => P;

Create a filtered view of the given project. Changes to the filtered view will affect the source project.
Parameter p
Parameter filter
function to filter file paths. Return true to eliminate a file {Promise}

function filterImmediateAutofixes

filterImmediateAutofixes: (
    autofixes: AutofixRegistration[],
    gi: GoalInvocation
) => AutofixRegistration[];

Filter any provided autofixes whose results were included in the commits of the current push.
Parameter autofixes
Parameter gi
Returns
{AutofixRegistration[]}

function findSdmGoalOnCommit

findSdmGoalOnCommit: (
    ctx: HandlerContext,
    id: RemoteRepoRef,
    providerId: string,
    goal: Goal
) => Promise<SdmGoalEvent>;

function firstAvailableProgressLog

firstAvailableProgressLog: (
    log: ProgressLog,
    ...moreLogs: ProgressLog[]
) => Promise<ProgressLog>;

Return the first available progress log. Error if none is available: Pass in a fallback that's always available.
Parameter log
first log
Parameter moreLogs
{Promise}

function format

format: (msg: string, ...args: any[]) => string;

Returns a formatted string replacing any placeholders in msg with provided args
See npm springf-js for more details on what args and placeholder patterns are supported.

function formatDate

formatDate: (date?: Date, format?: string, utc?: boolean) => string;

Format the date with provided format. Defaults to formatting the current UTC date with 'yyyymmddHHMMss' format.
Parameter date
Date object to format
Parameter format
dateformat compatible format
Parameter utc
if true, use UTC time, otherwise use local time zone properly formatted date string

function formatReviewerError

formatReviewerError: (err: ReviewerError) => slack.SlackMessage;

function generateCommitMessageForAutofix

generateCommitMessageForAutofix: (autofix: AutofixRegistration) => string;

Generate a commit message for the provided autofix.
Parameter autofix
Returns
{string}

function generatorCommand

generatorCommand: <P>(
    sdm: MachineOrMachineOptions,
    editorFactory: EditorFactory<P>,
    name: string,
    paramsMaker: Maker<P>,
    fallbackTarget: Maker<RepoCreationParameters>,
    startingPoint: StartingPoint<P>,
    details: Partial<GeneratorCommandDetails<any>>,
    cr: GeneratorRegistration<P>
) => HandleCommand;

Create a command handler for project generation
Parameter sdm
this machine or its options
Parameter editorFactory
to create editorCommand to perform transformation
Parameter paramsMaker
Parameter name
Parameter details
{HandleCommand}

function generatorRegistrationToCommand

generatorRegistrationToCommand: <P = any>(
    sdm: MachineOrMachineOptions,
    e: GeneratorRegistration<P>
) => Maker<HandleCommand<P>>;

function getGoalDefinitionFrom

getGoalDefinitionFrom: (
    goalDetails: FulfillableGoalDetails | string,
    uniqueName: string,
    definition?: GoalDefinition
) => { uniqueName: string } | PredicatedGoalDefinition;

Construct a PredicatedGoalDefinition from the provided goalDetails
Parameter goalDetails
Parameter uniqueName
Parameter definition

function gitBranchCompatible

gitBranchCompatible: (name: string) => string;

Takes a potential git branch name and returns a legalised iteration of it
Parameter name
the git branch name to sanitise.

function gitHubTeamVoter

gitHubTeamVoter: (team?: string) => GoalApprovalRequestVoter;

Goal approval request vote implementation that checks for GitHub team membership of the person who is requesting the approval .
Parameter team

function given

given: <V>(...givenPushTests: PushTest[]) => TreeContext<V>;

Simple DSL to create a decision tree. Trees and subtrees can compute variables as interim values for future use. Example usage, showing computed state:

let count = 0;  // Initialize a counter we'll use later
const pm: PushMapping<Goals> = given<Goals>(TruePushTest, ...) // Use any push tests
   .init(() => count = 0) // Init to set state
   .itMeans("no frogs coming")
   .then(
       given<Goals>(TruePushTest, ...).itMeans("case1")
          .compute(() => count++)   // Increment the counter for this branch
          .then(
             // Compute terminal rules
             whenPushSatisfies(count > 0, FalsePushTest).itMeans("nope").setGoals(NoGoals),
             whenPushSatisfies(TruePushTest).itMeans("yes").setGoals(HttpServiceGoals),
          ),
      );

Parameter givenPushTests

PushTests interim DSL structure

function goal

goal: (
    details?: FulfillableGoalDetails,
    goalExecutor?: ExecuteGoal,
    options?: {
        pushTest?: PushTest;
        logInterpreter?: InterpretLog;
        progressReporter?: ReportProgress;
        plan?: (
            pli: StatefulPushListenerInvocation,
            goals: Goals
        ) => Promise<PlannedGoals | PlannedGoal>;
    }
) => GoalWithFulfillment;

Creates a new GoalWithFulfillment instance using conventions if overwrites aren't provided
Call this from your machine.ts where you configure your sdm to create a custom goal.
Caution: if you wrap this in another function, then you MUST provide details.uniqueName, because the default is based on where in the code this goal function is called.
Parameter details
It is highly recommended that you supply at least uniqueName.
Parameter goalExecutor
Parameter options

function goalContributors

goalContributors: <F extends SdmContext = StatefulPushListenerInvocation<any>>(
    contributor: GoalContribution<F>,
    ...contributors: Array<GoalContribution<F>>
) => Mapping<F, Goals>;

Contribute goals based on a series of contribution rules.
Instead of stopping at the first match, each push will get _all_ the goals it qualifies for.
Duplicates will be removed.
Parameter contributor
first contributor
Parameter contributors
a mapping to goals

function goalCorrespondsToSdmGoal

goalCorrespondsToSdmGoal: (goal: Goal, sdmGoal: SdmGoalKey) => boolean;

function goalData

goalData: (sdmGoal: SdmGoalEvent) => any;

Read and parse goal event data. If the goal event has no data, return an empty object. Note: this purposely only works if the data field is stringified JSON.
Parameter sdmGoal
JSON parsed goal event data property

function goalKeyEquals

goalKeyEquals: (a: SdmGoalKey, b: SdmGoalKey) => boolean;

function goalKeyString

goalKeyString: (gk: SdmGoalKey) => string;

function goals

goals: (name: string) => Goals & GoalsBuilder;

Create Goals instance using a fluent API.
const simpleGoals = goals("Simple Goals") .plan(CodeInspectionGoal) .plan(BuildGoal, Autofix).after(CodeInspectionGoal) .plan(StagingEndpointGoal).after(BuildGoal) .plan(ProductionDeploymentGoal).after(BuildGoal, StagingEndpointGoal);
Parameter name
Returns
{Goals & GoalsBuilder}

function goalSetState

goalSetState: (
    goals: Array<Pick<SdmGoalMessage, 'name' | 'state'>>
) => SdmGoalState;

function goalTest

goalTest: (
    name: string,
    goalMapping: (
        goal: SdmGoalEvent,
        pli: StatefulPushListenerInvocation
    ) => Promise<boolean>,
    pushTest?: PushTest
) => GoalTest;

function handleSdmGoalSetEvent

handleSdmGoalSetEvent: (
    options: QueueOptions,
    definition: GoalDefinition,
    configuration: SoftwareDeliveryMachineConfiguration
) => OnEvent<OnAnySdmGoalSetSubscription>;

function hasCommit

hasCommit: (test: RegExp) => PushTest;

Push test that tests commit messages for a provided regular expression match

function hasFile

hasFile: (path: string) => PredicatePushTest;

Return a PushTest testing for the existence of the given file
Parameter path
{PushTest}

function hasFileContaining

hasFileContaining: (pattern: string | string[], content?: RegExp) => PushTest;

Return a PushTest testing for the existence of the given file containing the pattern
Parameter path
Parameter pattern
regex to look for {PushTest}

function hasFileWithExtension

hasFileWithExtension: (extension: string) => PredicatePushTest;

Is there at least one file with the given extension?
Parameter extension
{PredicatePushTest}

function hasGoalSettingStructure

hasGoalSettingStructure: <F, V>(
    m: Mapping<F, V>
) => m is GoalSettingStructure<F, V>;

function hasPreconditions

hasPreconditions: (goal: Goal) => goal is GoalWithPrecondition;

function hasResourceProvider

hasResourceProvider: (
    type: 'docker' | 'npm' | 'maven2',
    name?: string
) => PushTest;

Return a PushTest that checks if a certain resource provider exists in the graph

function isBranch

isBranch: (re: RegExp) => PushTest;

Return a push test that matches the repository branch against regular expression.
Parameter re
Regular expression to match against using RegExp.test() Push test performing the match

function isDeployEnabled

isDeployEnabled: (parameters: {
    context: HandlerContext;
    id: RepoRef;
}) => Promise<boolean>;

function isExplicableMapping

isExplicableMapping: <F, V>(
    input: Mapping<F, V>
) => input is ExplicableMapping<F, V, V>;

function isFailure

isFailure: (result: ExecuteGoalResult | void) => boolean;

Assert if a given ExecuteGoalResult describe a failure result
Parameter result

function isGoal

isGoal: (options?: {
    name?: string | RegExp;
    state?: SdmGoalState;
    output?: string | RegExp;
    pushTest?: PushTest;
    data?: string | RegExp;
}) => GoalTest;

function isGoalCanceled

isGoalCanceled: (sdmGoal: SdmGoalEvent, ctx: HandlerContext) => Promise<boolean>;

Check if current goal is already canceled

function isGoalDefinition

isGoalDefinition: (f: Goal | GoalDefinition) => f is GoalDefinition;

function isGoalFulfillment

isGoalFulfillment: (g: {
    fulfillment?: PlannedGoal['fulfillment'];
}) => g is { fulfillment: PlannedGoal['fulfillment'] };

function isGoalImplementation

isGoalImplementation: (f: GoalFulfillment) => f is GoalImplementation;

function isGoals

isGoals: (a: any) => a is Goals;

function isGoalSideEffect

isGoalSideEffect: (f: GoalFulfillment) => f is GoalSideEffect;

function isImplementation

isImplementation: (f: Fulfillment) => f is Implementation;

function isLazyProjectLoader

isLazyProjectLoader: (pl: ProjectLoader) => pl is LazyProjectLoader;

function isMapping

isMapping: (a: any) => a is Mapping<any, any>;

function isMaterialChange

isMaterialChange: (options?: MaterialChangeOptions) => PushTest;

Check if a Push represents a material change.
Material changes are changes to files that should trigger certain activity or goals. Often simple changes to MD or html files should not trigger a full CI/CD process.

function isPredicatedStaticValue

isPredicatedStaticValue: <T>(
    pushMapping: PushMapping<T>
) => pushMapping is StaticPushMapping<T> & Predicated<PushListenerInvocation>;

function isRepo

isRepo: (re: RegExp) => PushTest;

Return a push test that matches the repository owner/repo slug against regular expression.
Parameter re
Regular expression to match against using RegExp.test() Push test performing the match

function isRepoTargetingParameters

isRepoTargetingParameters: (p: any) => p is RepoTargetingParameters;

function isSdmEnabled

isSdmEnabled: (name: string) => PushTest;

Is this SDM enabled on the current project. Checks the .atomist/config.json at key sdm.enabled to see if the current SDM is listed.

function isSeedDrivenGeneratorParameters

isSeedDrivenGeneratorParameters: (p: any) => p is SeedDrivenGeneratorParameters;

function isSideEffect

isSideEffect: (f: Fulfillment) => f is SideEffect;

function isSuccess

isSuccess: (result: ExecuteGoalResult | void) => boolean;

Assert if a given ExecuteGoalResult describe a successful result
Parameter result

function isTransformModeSuggestion

isTransformModeSuggestion: (p: any) => p is TransformModeSuggestion;

function isValidationError

isValidationError: (vr: ValidationResult) => vr is ValidationError;

function killAndWait

killAndWait: (childProcess: ChildProcess, wait?: number) => Promise<void>;

Kill the process and wait for it to shut down. This can take a while as processes may have shut down hooks. On win32, the process is killed and the Promise is rejected if the process does not exit within wait milliseconds. On other platforms, first the process is sent the default signal, SIGTERM. After wait milliseconds, it is sent SIGKILL. After another wait milliseconds, an error is thrown.
Parameter childProcess
Child process to kill
Parameter wait
Number of milliseconds to wait before sending SIGKILL and then erroring, default is 30000 ms

function lastLinesLogInterpreter

lastLinesLogInterpreter: (message: string, lines?: number) => InterpretLog;

Generally useful InterpretLog that takes the last n logs of the log
Parameter message
Parameter lines
number of lines to take {InterpretLog}

function mapKeyToGoal

mapKeyToGoal: <T extends SdmGoalKey>(goals: T[]) => (k: SdmGoalKey) => T;

function mapMapping

mapMapping: <F, V1, V2>(
    inputMapping: Mapping<F, V1>,
    f: (v1: V1) => V2
) => Mapping<F, V2> & ExplicableMapping<F, V2, V1>;

function markStatus

markStatus: (parameters: {
    context: HandlerContext;
    goalEvent: SdmGoalEvent;
    goal: Goal;
    result: ExecuteGoalResult;
    error?: Error;
    progressLogUrl: string;
}) => Promise<void>;

function matchStringOrRegexp

matchStringOrRegexp: (pattern: string | RegExp, toMatch: string) => boolean;

function memoize

memoize: (pt: PushTest) => PushTest;

Cache the PushTest results for this push. The results will be cached based on the name of the pushTest and the ID of the push. Make sure your push test has a unique name!
Parameter pt
{PushTest}

function mergeGoalData

mergeGoalData: (data: any, sdmGoal: SdmGoalEvent) => any;

Return a shallow merge the provided data and the goal event data property, parsed as JSON. Properties in data take precedence over those in the parsed goal event data object.
Parameter data
Parameter sdmGoal
shallow merge of data and SDM goal event data property

function mergeOptions

mergeOptions: <OPTIONS>(
    defaults: OPTIONS,
    explicit: OPTIONS,
    configurationPath?: string
) => OPTIONS;

Merge Goal configuration options into a final options object. Starts off by merging the explicitly provided options over the provided defaults; finally merges the configuration values at the given configuration path (prefixed with sdm.) over the previous merge.
Parameter defaults
Parameter explicit
Parameter configurationPath

function messageDestinationsFor

messageDestinationsFor: (
    hasChannels: HasChannels,
    ctx?: HandlerContext
) => Destination[];

function metadata

metadata: (name?: string) => ExtensionPackMetadata;

Read ExtensionPackMetadata from the modules package.json.
Parameter name
Returns
{ExtensionPackMetadata}

function minimalClone

minimalClone: (push: PushFields.Fragment, extras?: CloneOptions) => CloneOptions;

function mockGoalExecutor

mockGoalExecutor: (
    goal: Goal,
    sdmGoal: SdmGoalEvent,
    configuration: SoftwareDeliveryMachineConfiguration
) => ExecuteGoal | undefined;

Create mock goal executor for a certain goal
Parameter goal
Parameter configuration

function notGoalOrOutputTest

notGoalOrOutputTest: (pushTest: PushTest) => PushTest;

Wrap a PushTest to make sure it doesn't get the chance to match on goal planning based on goal events

function notPredicate

notPredicate: (t: ProjectPredicate) => ProjectPredicate;

Return the opposite of this ProjectPredicate

function onAnyPush

onAnyPush: <
    P extends PushListenerInvocation = PushListenerInvocation
>() => GoalSetterMapping<P>;

PushRule that matches every push {GoalSetterMapping}

function patternMatchReviewer

patternMatchReviewer: (
    name: string,
    opts: PatternMatchReviewerOptions,
    ...antiPatterns: AntiPattern[]
) => ReviewerRegistration;

Return a ReviewerRegistration that objects to the given antipatterns and looks in the specified files
Parameter name
Parameter opts
targeting options
Parameter antiPatterns
{ReviewerRegistration}

function planGoals

planGoals: (goals: Goals, pli: PushListenerInvocation) => Promise<Goals>;

function preconditionsAreMet

preconditionsAreMet: (
    goal: SdmGoalEvent,
    info: { goalsForCommit: SdmGoalEvent[] }
) => boolean;

function predicatePushTest

predicatePushTest: (
    name: string,
    predicate: ProjectPredicate
) => PredicatePushTest;

Convenient factory function for PushTest instances based on project predicates. Also exposes project predicate
Parameter name
Parameter predicate
test function for projects {PushTest}

function prepareGoalExecutor

prepareGoalExecutor: (
    gi: GoalImplementation,
    sdmGoal: SdmGoalEvent,
    configuration: SoftwareDeliveryMachineConfiguration
) => ExecuteGoal;

function prepareGoalInvocation

prepareGoalInvocation: (
    gi: GoalInvocation,
    listeners: GoalProjectListenerRegistration | GoalProjectListenerRegistration[]
) => GoalInvocation;

function projectConfigurationValue

projectConfigurationValue: <T>(
    path: string,
    p: Project,
    defaultValue?: T
) => Promise<T>;

Gather a configuration value from:
1) within a file .atomist/config.json or .atomist/config.yaml within the Project 2) from within the sdm property in the wider, globally available configuration. For where these come from, see: https://atomist.github.io/automation-client/modules/_lib_configuration_.html#loadconfiguration 3) the default passed in, if any 4) ... or else throw.
This will not merge the configuration objects. It gives the first one that is not undefined.

function projectLoaderRepoLoader

projectLoaderRepoLoader: (
    pl: ProjectLoader,
    credentials: ProjectOperationCredentials,
    readOnly: boolean,
    context?: HandlerContext
) => RepoLoader;

Adapter from newer ProjectLoader to older RepoLoader for use in editors
Parameter pl
ProjectLoader
Parameter credentials
credentials to use to load projects
Parameter readOnly
is the use read only? {RepoLoader}

function pushTest

pushTest: (
    name: string,
    mapping: (p: StatefulPushListenerInvocation) => Promise<boolean>
) => PushTest;

Convenient factory function for PushTest instances
Parameter name
Parameter mapping
test function {PushTest}

function randomize

randomize: (size: MockGoalSize | number, randomBy: number) => number;

function registerRegistrable

registerRegistrable: (registrable: Registerable) => void;

function registrableManager

registrableManager: () => Registerable;

function relevantCodeActions

relevantCodeActions: <R extends PushSelector>(
    registrations: R[],
    pli: PushImpactListenerInvocation
) => Promise<R[]>;

Compute the relevant actions for this push. Some may be filtered out by their push tests.

function reportFailureInterpretation

reportFailureInterpretation: (
    stepName: string,
    interpretation: InterpretedLog | undefined,
    fullLog: { url?: string; log: string },
    id: RemoteRepoRef,
    addressChannels: AddressChannels,
    retryButton?: slack.Action
) => Promise<void>;

function resetRegistrableManager

resetRegistrableManager: () => void;

function resolveCredentialsPromise

resolveCredentialsPromise: (
    creds: Promise<ProjectOperationCredentials> | ProjectOperationCredentials
) => Promise<ProjectOperationCredentials>;

function save

save: (
    pl: ProjectLoader,
    params: ProjectLoadingParameters
) => Promise<GitProject>;

Delegate to the underlying ProjectLoader to load the project.
Parameter pl
Parameter params

function sdmGoalTimeout

sdmGoalTimeout: (cfg?: Configuration) => number;

Return configured SDM goal timeout or default value, 10 minutes.

function serializeResult

serializeResult: (result: any) => string;

function severityReviewListener

severityReviewListener: (
    pir: PushImpactResponse,
    severity?: Severity
) => Function1<I, Promise<R>>;

Return review listener function that returns pir if there are any review comments with the provided severity. The method will short circuit once any comment with the provided severity is found.
Parameter pir
push impact response to return if there are comments with provided severities
Parameter severity
severity that should trigger a return of pir, "error" by default ReviewListener that returns pir if any comments have a severity of severity, proceed otherwise

function slackErrorMessage

slackErrorMessage: (
    title: string,
    text: string,
    ctx: HandlerContext,
    options?: Attachment
) => SlackMessage;

function slackFooter

slackFooter: () => string;

function slackInfoMessage

slackInfoMessage: (
    title: string,
    text: string,
    options?: Attachment
) => SlackMessage;

function slackQuestionMessage

slackQuestionMessage: (
    title: string,
    text: string,
    options?: Attachment
) => SlackMessage;

function slackReviewListener

slackReviewListener: (
    opts?: Partial<SlackReviewRoutingParams>
) => Function1<I, Promise<R>>;

Route reviews to Slack in linked channels

function slackReviewListenerRegistration

slackReviewListenerRegistration: (
    opts?: Partial<SlackReviewRoutingParams>
) => ReviewListenerRegistration;

function slackSuccessMessage

slackSuccessMessage: (
    title: string,
    text: string,
    options?: Attachment
) => SlackMessage;

function slackSupportLink

slackSupportLink: (ctx: HandlerContext) => string;

function slackTs

slackTs: () => number;

function slackWarningMessage

slackWarningMessage: (
    title: string,
    text: string,
    ctx: HandlerContext,
    options?: Attachment
) => SlackMessage;

function spawnAutofix

spawnAutofix: (
    name: string,
    pushTest: PushTest,
    options: AutofixRegistrationOptions,
    command1: SpawnLogInvocation,
    ...additionalCommands: SpawnLogInvocation[]
) => AutofixRegistration;

Create an autofix registration from one or more external commands.

function spawnCodeTransform

spawnCodeTransform: (
    commands: SpawnLogInvocation[],
    log?: ProgressLog
) => CodeTransform;

Create a code transform by wrapping child processes run in the project directory. If a command fails, no further commands will be run and its error will be returned.
Parameter commands
array of commands to execute
Parameter log
where to log output from commands result of commands, success or the first failure

function spawnLog

spawnLog: (
    cmd: string,
    args: string[],
    opts: SpawnLogOptions
) => Promise<SpawnLogResult>;

Spawn a process, logging its standard output and standard error, and return a Promise of its results. The command is spawned using cross-spawn. A DelimitedWriteProgressLogDecorator, using newlines as delimiters, is created from the provided opts.log. The default command timeout is 10 minutes. The default [[SpawnLogOptions#errorFinder]] sets the error property if the command exits with a non-zero status or is killed by a signal. If the process is killed due to a signal or the errorFinder returns true, the returned code property will be non-zero.
Parameter cmd
Command to run.
Parameter args
Arguments to command.
Parameter opts
Options for spawn, spawnPromise, and spawnLog. A promise that provides information on the child process and its execution result, including if the exit status was non-zero or the process was killed by a signal. The promise is only rejected with an ExecPromiseError if there is an error spawning the process.

function storeGoal

storeGoal: (
    ctx: HandlerContext,
    sdmGoal: SdmGoalMessage
) => Promise<SdmGoalMessage>;

function storeGoalSet

storeGoalSet: (ctx: HandlerContext, goalSet: SdmGoalSetMessage) => Promise<void>;

function streamFiles

streamFiles: (
    donorProject: Project,
    fileGlobMapping: FileGlobMapping
) => CodeTransform;

function streamFilesFrom

streamFilesFrom: (
    donorProjectId: RemoteRepoRef,
    fileGlobMapping: FileGlobMapping
) => CodeTransform;

Take the specified files from the donor project
Parameter donorProjectId
Parameter fileGlobMapping
treated as globs as defined in Project.streamFiles {SimpleProjectEditor}

function suggestAction

suggestAction: (suggestion: ActionSuggestion) => Goal;

Return a goal that suggests an action to the user.

function sumSdmGoalEvents

sumSdmGoalEvents: (some: SdmGoalEvent[]) => SdmGoalEvent[];

function testProgressReporter

testProgressReporter: (...tests: ProgressTest[]) => ReportProgress;

ReportProgress implementation that uses RexExp tests to extract progess
Parameter tests
Returns
{ReportProgress}

function toCommandListenerInvocation

toCommandListenerInvocation: <P>(
    c: CommandRegistration<P>,
    context: HandlerContext,
    parameters: P,
    sdm: SoftwareDeliveryMachineOptions
) => CommandListenerInvocation;

function toGeneratorParametersMaker

toGeneratorParametersMaker: <PARAMS>(
    paramsMaker: Maker<PARAMS>,
    target: RepoCreationParameters
) => Maker<any>;

Return a parameters maker that is targeting aware
Parameter paramsMaker
{Maker<EditorOrReviewerParameters & PARAMS>}

function toGoals

toGoals: (gc: GoalComponent) => Goals;

Convert a GoalComponent to Goals
Parameter gc
{Goals}

function toMachineOptions

toMachineOptions: (m: MachineOrMachineOptions) => SoftwareDeliveryMachineOptions;

function toParametersListing

toParametersListing: (p: ParametersDefinition<any>) => ParametersListing;

function toPredicateMapping

toPredicateMapping: <F>(p: PredicateMappingTerm<F>) => PredicateMapping<F>;

Convert a PredicateMapping term to a PredicateMapping
Parameter p
{PredicateMapping}

function toProjectAwareGoalInvocation

toProjectAwareGoalInvocation: (
    project: GitProject,
    gi: GoalInvocation
) => ProjectAwareGoalInvocation;

Convenience method to create project aware goal invocations with spawn and exec functions that, by default, use the cloned project base directory as the current working directory.
Parameter project
locally cloned project
Parameter gi
SDM goal invocation goal invocation made project aware

function toPushReactionRegistration

toPushReactionRegistration: (
    prr: PushImpactListenerRegisterable
) => PushImpactListenerRegistration<DefaultPushImpactListenerResult>;

Convert an action function to a PushImpactListener if necessary
Parameter prr
{PushImpactListenerRegistration}

function toRepoTargetingParametersMaker

toRepoTargetingParametersMaker: <PARAMS>(
    paramsMaker: Maker<PARAMS>,
    targets: Maker<RepoTargets>
) => Maker<RepoTargetingParameters & PARAMS>;

Return a parameters maker that is targeting aware
Parameter paramsMaker
Parameter targets
targets parameters to set if necessary {Maker<EditorOrReviewerParameters & PARAMS>}

function toScalarProjectEditor

toScalarProjectEditor: <PARAMS>(
    ctot: CodeTransformOrTransforms<PARAMS>,
    sdm: SoftwareDeliveryMachineOptions,
    projectPredicate?: ProjectPredicate
) => ProjectEditor<PARAMS>;

Convert to legacy automation-client "editor" signature
Parameter ctot
Parameter projectPredicate
{ProjectEditor}

function toToken

toToken: (credentials: ProjectOperationCredentials | string) => string;

Convert the given credentials or token string to a token string if possible. Otherwise throw an exception.
Parameter credentials
{string}

function transformToProjectListener

transformToProjectListener: (
    transform: CodeTransform,
    name: string,
    pushTest?: PushTest
) => GoalProjectListenerRegistration;

Convert a CodeTransform to a GoalProjectListener
Parameter transform
Parameter name
Parameter pushTest

function updateGoal

updateGoal: (
    ctx: HandlerContext,
    before: SdmGoalEvent,
    params: UpdateSdmGoalParams
) => Promise<void>;

function validateConfigurationValues

validateConfigurationValues: (config: any, options: ConfigurationValues) => void;

Validate the provided configuration
Parameter config
Parameter options

function visitPredicateMappings

visitPredicateMappings: <F>(
    pm: PredicateMapping<F>,
    v: PredicateMappingVisitor<F>
) => void;

Visit the PredicateMappings, returning whether to continue
Parameter pm
predicate mapping to visit. Always visits root, and any subcomponents as long as the visitor returns true
Parameter v
visitor {boolean} whether to visit the mapping's structure, if any

function whenNot

whenNot: <F>(t: PredicateMapping<F>) => PredicateMapping<F>;

Return the opposite of this predicate mapping

function whenPushSatisfies

whenPushSatisfies: <P extends PushListenerInvocation = PushListenerInvocation>(
    guard1: PredicateMappingTerm<P>,
    ...guards: Array<PredicateMappingTerm<P>>
) => GoalSetterMapping<P>;

Simple GoalSetter DSL. Allows use of booleans and functions returning boolean in predicate expressions
Parameter guard1
Parameter guards

function wrapPredicateMapping

wrapPredicateMapping: <
    P extends PushListenerInvocation = PushListenerInvocation
>(
    guards: PredicateMapping<P>
) => PredicateMapping<P>;

function wrapTest

wrapTest: <P extends PushListenerInvocation = PushListenerInvocation>(
    test: PredicateMapping<P>
) => PredicateMapping<P>;

Classes

class AbstractSoftwareDeliveryMachine

abstract class AbstractSoftwareDeliveryMachine<
        O extends SoftwareDeliveryMachineConfiguration = SoftwareDeliveryMachineConfiguration
    >
    extends ListenerRegistrationManagerSupport
    implements SoftwareDeliveryMachine<O> {}

Abstract support class for implementing a SoftwareDeliveryMachine.

constructor

protected constructor(
    name: string,
    configuration: SoftwareDeliveryMachineConfiguration<{}>,
    goalSetters: (
        | GoalSetter<PushListenerInvocation>
        | GoalSetter<PushListenerInvocation>[]
    )[]
);

Construct a new software delivery machine, with zero or more goal setters.
Parameter name
Parameter configuration
automation client configuration we're running in
Parameter goalSetters
tell me what to do on a push. Hint: start with "whenPushSatisfies(...)"

property commandHandlers

abstract readonly commandHandlers: Maker<HandleCommand>[];

property configuration

readonly configuration: SoftwareDeliveryMachineConfiguration<{}>;

property disposalGoalSetters

protected readonly disposalGoalSetters: GoalSetter<PushListenerInvocation>[];

property eventHandlers

abstract readonly eventHandlers: Maker<HandleEvent<any>>[];

property extensionPacks

readonly extensionPacks: ExtensionPack[];

property goalApprovalRequestVoteDecisionManager

protected goalApprovalRequestVoteDecisionManager: GoalApprovalRequestVoteDecisionManager;

property goalApprovalRequestVoters

protected readonly goalApprovalRequestVoters: GoalApprovalRequestVoter[];

property goalFulfillmentMapper

readonly goalFulfillmentMapper: DefaultGoalImplementationMapper;

property ingesters

abstract readonly ingesters: string[];

property name

readonly name: string;

property pushMapping

readonly pushMapping: PushMapping<Goals>;

Return the PushMapping that will be used on pushes. Useful in testing goal setting. {PushMapping}

property registrationManager

protected readonly registrationManager: HandlerRegistrationManagerSupport;

method addCodeInspectionCommand

addCodeInspectionCommand: <R, P>(cir: CodeInspectionRegistration<R, P>) => this;

method addCodeTransformCommand

addCodeTransformCommand: <P>(ct: CodeTransformRegistration<P>) => this;

method addCommand

addCommand: <P>(cmd: CommandHandlerRegistration<P>) => this;

method addEvent

addEvent: <T, P>(e: EventHandlerRegistration<T, P>) => this;

method addExtensionPacks

addExtensionPacks: (...packs: ExtensionPack[]) => this;

method addGeneratorCommand

addGeneratorCommand: <P = NoParameters>(gen: GeneratorRegistration<P>) => this;

method addGoalApprovalRequestVoter

addGoalApprovalRequestVoter: (vote: GoalApprovalRequestVoter) => this;

method addGoalContributions

addGoalContributions: (
    goalContributions: GoalSetter<PushListenerInvocation>
) => this;

method addGoalImplementation

addGoalImplementation: (
    implementationName: string,
    goal: Goal,
    goalExecutor: ExecuteGoal,
    options?: Partial<{
        pushTest: PushTest;
        logInterpreter: InterpretLog;
        progressReporter: ReportProgress;
        projectListeners:
            | GoalProjectListenerRegistration
            | GoalProjectListenerRegistration[];
    }>
) => this;

Provide the implementation for a goal. The SDM will run it as soon as the goal is ready (all preconditions are met). If you provide a PushTest, then the SDM can assign different implementations to the same goal based on the code in the project.
Parameter implementationName
Parameter goal
Parameter goalExecutor
Parameter options
PushTest to narrow matching & InterpretLog that can handle the log from the goalExecutor function {this}

method addGoalSideEffect

addGoalSideEffect: (
    goal: Goal,
    sideEffectName: string,
    registration?: string,
    pushTest?: PushTest
) => this;

Declare that a goal will become successful based on something outside. For instance, ArtifactGoal succeeds because of an ImageLink event. This tells the SDM that it does not need to run anything when this goal becomes ready.

method addIngester

addIngester: (i: string | IngesterRegistration) => this;

method notifyStartupListeners

notifyStartupListeners: () => Promise<void>;

Invoke StartupListeners.

method scheduleTriggeredListeners

scheduleTriggeredListeners: () => void;

Schedule the triggered listeners

method setGoalApprovalRequestVoteDecisionManager

setGoalApprovalRequestVoteDecisionManager: (
    manager: GoalApprovalRequestVoteDecisionManager
) => this;

method withPushRules

withPushRules: (
    contributor: GoalContribution<any>,
    ...contributors: Array<GoalContribution<any>>
) => this;

class AutoCodeInspection

class AutoCodeInspection extends FulfillableGoalWithRegistrationsAndListeners<
    AutoInspectRegistration<any, any>,
    ReviewListenerRegistration
> {}

Goal that runs code inspections

constructor

constructor(
    details?: FulfillableGoalDetails & AutoCodeInspectionOptions,
    ...dependsOn: Goal[]
);

class Autofix

class Autofix extends FulfillableGoalWithRegistrations<AutofixRegistration<any>> {}

Goal that performs autofixes: For example, linting and adding license headers.

constructor

constructor(
    goalDetailsOrUniqueName?: string | AutofixGoalDetails,
    ...dependsOn: Goal[]
);

method withTransform

withTransform: (transform: CodeTransform<any>, name?: string) => this;

Add given transform to this Autofix goal
Parameter transform
Parameter name

class BitBucketRepoCreationParameters

class BitBucketRepoCreationParameters extends NewRepoCreationParameters {}

property apiUrl

apiUrl: string;

property credentials

readonly credentials: ProjectOperationCredentials;

property githubToken

githubToken: string;

property repoRef

readonly repoRef: RemoteRepoRef;

Return a single RepoRef or undefined if we're not identifying a single repo This implementation returns a GitHub.com repo but it can be overriden to return any kind of repo {RepoRef}

class BitBucketRepoTargets

class BitBucketRepoTargets
    extends TargetsParams
    implements FallbackParams, RepoTargets {}

Targets for working with BitBucket repo(s). Allows use of regex.

constructor

constructor();

property apiUrl

apiUrl: string;

property branch

branch: string;

property credentials

readonly credentials: ProjectOperationCredentials;

property owner

owner: string;

property repo

repo: string;

property repoRef

readonly repoRef: BitBucketServerRepoRef;

Return a single RepoRef or undefined if we're not identifying a single repo {RepoRef}

property repos

repos: string;

property sha

sha: string;

method bindAndValidate

bindAndValidate: () => ValidationResult;

class CachingProjectLoader

class CachingProjectLoader implements ProjectLoader {}

Caching implementation of ProjectLoader

constructor

constructor(delegate?: ProjectLoader, maxEntries?: number);

method doWithProject

doWithProject: <T>(
    params: ProjectLoadingParameters,
    action: WithLoadedProject<T>
) => Promise<T>;

class Cancel

class Cancel extends FulfillableGoal {}

Goal to cancel pending goals in goal sets of the previous commit on the same branch

constructor

constructor(
    options?: FulfillableGoalDetails & CancelOptions,
    ...dependsOn: Goal[]
);

class CommandListenerExecutionInterruptError

class CommandListenerExecutionInterruptError extends Error {}

constructor

constructor(message: string);

property message

readonly message: string;

class DefaultGoalImplementationMapper

class DefaultGoalImplementationMapper implements GoalImplementationMapper {}

Concrete implementation of GoalImplementationMapper

method addFulfillmentCallback

addFulfillmentCallback: (callback: GoalFulfillmentCallback) => this;

method addImplementation

addImplementation: (implementation: GoalImplementation) => this;

method addSideEffect

addSideEffect: (sideEffect: GoalSideEffect) => this;

method findFulfillmentByPush

findFulfillmentByPush: (
    goal: Goal,
    inv: PushListenerInvocation
) => Promise<GoalFulfillment | undefined>;

method findFulfillmentCallbackForGoal

findFulfillmentCallbackForGoal: (
    sdmGoal: SdmGoalEvent
) => GoalFulfillmentCallback[];

method findGoalBySdmGoal

findGoalBySdmGoal: (sdmGoal: SdmGoalEvent) => Goal | undefined;

method findImplementationBySdmGoal

findImplementationBySdmGoal: (goal: SdmGoalEvent) => GoalImplementation;

method hasImplementation

hasImplementation: () => boolean;

class DelimitedWriteProgressLogDecorator

class DelimitedWriteProgressLogDecorator implements ProgressLog {}

Sometimes new log lines are separated by a character rather than a call to write. For example, when receiving data events from a child process newlines delimit log lines.

constructor

constructor(delegate: ProgressLog, lineDelimiter: string);

property log

readonly log: string;

property name

readonly name: string;

property url

readonly url: string;

method close

close: () => Promise<void>;

method flush

flush: () => Promise<void>;

method isAvailable

isAvailable: () => Promise<boolean>;

method write

write: (msg: string, ...args: string[]) => void;

class FulfillableGoal

abstract class FulfillableGoal
    extends GoalWithPrecondition
    implements Registerable, PlannableGoal {}

Goal that registers goal implementations, side effects and callbacks on the current SDM. No additional registration with the SDM is needed.

constructor

constructor(
    definitionOrGoal: Goal | PredicatedGoalDefinition,
    ...dependsOn: Goal[]
);

property callbacks

readonly callbacks: GoalFulfillmentCallback[];

property definitionOrGoal

definitionOrGoal: Goal | PredicatedGoalDefinition;

property fulfillments

readonly fulfillments: Fulfillment[];

property goalListeners

readonly goalListeners: Function1<I, Promise<R>>[];

property projectListeners

readonly projectListeners: GoalProjectListenerRegistration[];

property sdm

sdm: SoftwareDeliveryMachine<SoftwareDeliveryMachineConfiguration<{}>>;

method addFulfillment

protected addFulfillment: (fulfillment: Fulfillment) => this;

method addFulfillmentCallback

protected addFulfillmentCallback: (cb: GoalFulfillmentCallback) => this;

method plan

plan: (
    pli: StatefulPushListenerInvocation,
    goals: Goals
) => Promise<PlannedGoals | PlannedGoal>;

method register

register: (sdm: SoftwareDeliveryMachine) => void;

method withExecutionListener

withExecutionListener: (listener: Function1<I, Promise<R>>) => this;

method withProjectListener

withProjectListener: (listener: GoalProjectListenerRegistration) => this;

method withService

withService: (registration: ServiceRegistration<any>) => this;

class FulfillableGoalWithRegistrations

abstract class FulfillableGoalWithRegistrations<R> extends FulfillableGoal {}

Goal that accepts registrations of R.

constructor

constructor(
    definitionOrGoal: Goal | PredicatedGoalDefinition,
    ...dependsOn: Goal[]
);

property definitionOrGoal

definitionOrGoal: Goal | PredicatedGoalDefinition;

property registrations

readonly registrations: R[];

method with

with: (registration: R) => this;

class FulfillableGoalWithRegistrationsAndListeners

abstract class FulfillableGoalWithRegistrationsAndListeners<
    R,
    L
> extends FulfillableGoalWithRegistrations<R> {}

Goal that accepts registrations of R and listeners of L.

constructor

constructor(
    definitionOrGoal: Goal | PredicatedGoalDefinition,
    ...dependsOn: Goal[]
);

property definitionOrGoal

definitionOrGoal: Goal | PredicatedGoalDefinition;

property listeners

readonly listeners: L[];

method withListener

withListener: (listener: L) => this;

class GitHubIssueRouter

class GitHubIssueRouter implements IssueRouter {}

GitHub implementation of IssueRouter

method raiseIssue

raiseIssue: (
    credentials: ProjectOperationCredentials,
    id: RemoteRepoRef,
    issue: Issue
) => Promise<void>;

class GitHubLazyProjectLoader

class GitHubLazyProjectLoader implements LazyProjectLoader {}

Create a lazy view of the given project GitHub, which will materialize the remote project (usually by cloning) only if needed.

constructor

constructor(delegate: ProjectLoader);

property isLazy

readonly isLazy: boolean;

method doWithProject

doWithProject: <T>(
    params: ProjectLoadingParameters,
    action: WithLoadedLazyProject<T>
) => Promise<T>;

class GitHubRepoTargets

class GitHubRepoTargets
    extends GitHubTargetsParams
    implements FallbackParams, RepoTargets {}

Resolve from a Mapped parameter or from a supplied repos regex if no repo mapping

property branch

branch: string;

property owner

owner: string;

property repo

repo: string;

property repos

repos: string;

property sha

sha: string;

method bindAndValidate

bindAndValidate: () => ValidationResult;

class GitlabRepoTargets

class GitlabRepoTargets
    extends TargetsParams
    implements FallbackParams, RepoTargets {}

Targets for working with BitBucket repo(s). Allows use of regex.

constructor

constructor();

property apiUrl

apiUrl: string;

property branch

branch: string;

property credentials

readonly credentials: ProjectOperationCredentials;

property owner

owner: string;

property repo

repo: string;

property repoRef

readonly repoRef: GitlabRepoRef;

Return a single RepoRef or undefined if we're not identifying a single repo {RepoRef}

property repos

repos: string;

property sha

sha: string;

property url

url: string;

method bindAndValidate

bindAndValidate: () => ValidationResult;

class GivenTree

class GivenTree<V> {}

Tree. Can compute variables

constructor

constructor(givenPushTest: PushTest, name: string);

method compute

compute: (f: (t: this) => any) => any;

Perform computation before continuing. Typically used to set values that will be used in predicate expressions.
Parameter f
{any}

method set

set: (value: V) => PushMapping<V>;

Set the resolution value of this tree
Parameter value
{PushMapping}

method then

then: (...pushMappings: Array<PushMapping<V>>) => PushMapping<V>;

Enter a subtree of a number of mappings. Can be use to nest trees to arbitrary depth.
Parameter pushMappings
{PushMapping}

class Goal

class Goal {}

Represents a delivery action, such as Build or Deploy.

constructor

constructor(definition: GoalDefinition);

property canceledDescription

readonly canceledDescription: string;

property context

readonly context: string;

property definition

readonly definition: GoalDefinition;

property environment

readonly environment: string;

property failureDescription

readonly failureDescription: string;

property inProcessDescription

readonly inProcessDescription: string;

property name

readonly name: string;

property plannedDescription

readonly plannedDescription: string;

property requestedDescription

readonly requestedDescription: string;

property skippedDescription

readonly skippedDescription: string;

property stoppedDescription

readonly stoppedDescription: string;

property successDescription

readonly successDescription: string;

property uniqueName

readonly uniqueName: string;

property waitingForApprovalDescription

readonly waitingForApprovalDescription: string;

property waitingForPreApprovalDescription

readonly waitingForPreApprovalDescription: string;

class Goals

class Goals {}

Represents goals set in response to a push

constructor

constructor(name: string, ...goals: Goal[]);

property goals

readonly goals: Goal[];

property name

name: string;

method and

and: (g: Goal) => Goals;

Return a Goal set that contains these goals and one more goal, with an appropriate name
Parameter g
goal to add {Goals}

method andLock

andLock: () => Goals;

Return a form of these goals that is locked, so that more goals cannot be added through contribution model {Goals}

class GoalSetterMapping

class GoalSetterMapping<
    P extends PushListenerInvocation = PushListenerInvocation
> extends PushRule<Goals> {}

PushRule implementation exposed in DSL. Continues fluent API.

constructor

constructor(guard1: PushTest, guards: PushTest[], reason?: string);

property label

readonly label: string;

method setGoals

setGoals: (goalComponent: GoalComponent) => this;

method setGoalsWhen

setGoalsWhen: (f: (inv: P) => GoalComponent | Promise<GoalComponent>) => this;

Set goals dynamically, depending on this push
Parameter f
{this}

method setNoMoreGoals

setNoMoreGoals: (name?: string) => void;

Prevent setting any further goals on this push. Ordering matters: goals may previously have been set.
Parameter name
name of the empty Goals. Default is "No Goals"

class GoalWithFulfillment

class GoalWithFulfillment extends FulfillableGoal {}

Generic goal that can be used with a GoalDefinition. Register goal implementations or side effects to this goal instance.

method with

with: (fulfillment: Fulfillment) => this;

method withCallback

withCallback: (cb: GoalFulfillmentCallback) => this;

class GoalWithPrecondition

class GoalWithPrecondition extends Goal {}

constructor

constructor(definition: GoalDefinition, ...dependsOn: Goal[]);

property dependsOn

readonly dependsOn: Goal[];

class HandlerRegistrationManagerSupport

class HandlerRegistrationManagerSupport
    implements
        CommandRegistrationManager,
        EventRegistrationManager,
        IngesterRegistrationManager {}

Concrete implementation of CommandRegistrationManager and HandlerRegistrationManager

constructor

constructor(sdm: MachineOrMachineOptions);

property commandHandlers

commandHandlers: Maker<HandleCommand>[];

property eventHandlers

eventHandlers: Maker<HandleEvent<any>>[];

property ingesters

ingesters: string[];

method addCodeInspectionCommand

addCodeInspectionCommand: <R, P = NoParameters>(
    cir: CodeInspectionRegistration<R, P>
) => this;

method addCodeTransformCommand

addCodeTransformCommand: <P>(ed: CodeTransformRegistration<P>) => this;

method addCommand

addCommand: <P>(cmd: CommandHandlerRegistration<P>) => this;

method addEvent

addEvent: <T, P>(e: EventHandlerRegistration<T, P>) => this;

method addGeneratorCommand

addGeneratorCommand: <P = NoParameters>(gen: GeneratorRegistration<P>) => this;

method addIngester

addIngester: (i: IngesterRegistration) => this;

class ListenerRegistrationManagerSupport

class ListenerRegistrationManagerSupport implements ListenerRegistrationManager {}

Listener management offering a fluent builder pattern for registrations. This class is purely a registration store, and has no other behavior.

property channelLinkListeners

readonly channelLinkListeners: Function1<I, Promise<R>>[];

property closedIssueListeners

readonly closedIssueListeners: Function1<I, Promise<R>>[];

property firstPushListeners

readonly firstPushListeners: Function1<I, Promise<R>>[];

property goalCompletionListeners

readonly goalCompletionListeners: Function1<I, Promise<R>>[];

property goalExecutionListeners

readonly goalExecutionListeners: Function1<I, Promise<R>>[];

property goalsSetListeners

readonly goalsSetListeners: Function1<I, Promise<R>>[];

property newIssueListeners

readonly newIssueListeners: Function1<I, Promise<R>>[];

property pullRequestListeners

readonly pullRequestListeners: Function1<I, Promise<R>>[];

property repoCreationListeners

readonly repoCreationListeners: Function1<I, Promise<R>>[];

property repoOnboardingListeners

readonly repoOnboardingListeners: Function1<I, Promise<R>>[];

property startupListeners

readonly startupListeners: Function1<AdminCommunicationContext, Promise<void>>[];

property tagListeners

readonly tagListeners: Function1<I, Promise<R>>[];

property triggeredListeners

readonly triggeredListeners: TriggeredListenerRegistration[];

property updatedIssueListeners

readonly updatedIssueListeners: Function1<I, Promise<R>>[];

property userJoiningChannelListeners

readonly userJoiningChannelListeners: Function1<I, Promise<R>>[];

method addChannelLinkListener

addChannelLinkListener: (e: Function1<I, Promise<R>>) => this;

method addClosedIssueListener

addClosedIssueListener: (e: Function1<I, Promise<R>>) => this;

method addFirstPushListener

addFirstPushListener: (pls: Function1<I, Promise<R>>) => this;

method addGoalCompletionListener

addGoalCompletionListener: (l: Function1<I, Promise<R>>) => this;

method addGoalExecutionListener

addGoalExecutionListener: (e: Function1<I, Promise<R>>) => this;

method addGoalsSetListener

addGoalsSetListener: (l: Function1<I, Promise<R>>) => this;

method addNewIssueListener

addNewIssueListener: (e: Function1<I, Promise<R>>) => this;

method addPullRequestListener

addPullRequestListener: (pls: Function1<I, Promise<R>>) => this;

method addRepoCreationListener

addRepoCreationListener: (rcls: Function1<I, Promise<R>>) => this;

method addRepoOnboardingListener

addRepoOnboardingListener: (rols: Function1<I, Promise<R>>) => this;

method addStartupListener

addStartupListener: (
    l: Function1<AdminCommunicationContext, Promise<void>>
) => this;

method addTagListener

addTagListener: (e: Function1<I, Promise<R>>) => this;

method addTriggeredListener

addTriggeredListener: (t: TriggeredListenerRegistration) => this;

method addUpdatedIssueListener

addUpdatedIssueListener: (e: Function1<I, Promise<R>>) => this;

method addUserJoiningChannelListener

addUserJoiningChannelListener: (l: Function1<I, Promise<R>>) => this;

class LoggingProgressLog

class LoggingProgressLog implements ProgressLog {}

Progress log to logger, at a desired logging level

constructor

constructor(name: string, level?: 'debug' | 'info');

property log

log: string;

property name

name: string;

method close

close: () => Promise<void>;

method flush

flush: () => Promise<void>;

method isAvailable

isAvailable: () => Promise<boolean>;

method write

write: (msg: string, ...args: string[]) => void;

class LruCache

class LruCache<T> implements SimpleCache<T> {}

Simple Map-based cache. Based on https://medium.com/spektrakel-blog/a-simple-lru-cache-in-typescript-cba0d9807c40

constructor

constructor(maxEntries?: number, evictCallback?: (t: T) => void);

property stats

readonly stats: { hits: number; gets: number };

method evict

evict: (key: string) => boolean;

method get

get: (key: string) => T;

method put

put: (key: string, value: T) => void;

class ParametersBuilder

class ParametersBuilder implements ParametersListing {}

Fluent builder for command parameters. Similar to inquirer.js API.

property mappedParameters

mappedParameters: NamedMappedParameter[];

property parameters

parameters: any[];

property secrets

secrets: NamedSecret[];

property values

values: NamedValueParameter[];

method addMappedParameters

addMappedParameters: (
    mp: NamedMappedParameter,
    ...more: NamedMappedParameter[]
) => this;

Declare a new mapped parameter for a command {this}

method addParameters

addParameters: (p: NamedParameter, ...more: NamedParameter[]) => this;

Declare a new parameter for a command {this}

method addSecrets

addSecrets: (s: NamedSecret, ...more: NamedSecret[]) => this;

Declare a new secret parameter for a command {this}

method addValues

addValues: (s: NamedValue, ...more: NamedValue[]) => this;

Declare a new configuration value parameter for a command {this}

class ProjectListenerInvokingProjectLoader

class ProjectListenerInvokingProjectLoader implements ProjectLoader {}

ProjectLoader implementation that invokes GoalProjectListener instances on the loaded project. Can be used to restore state into a project/workspace area.

constructor

constructor(gi: GoalInvocation, listeners: GoalProjectListenerRegistration[]);

method doWithProject

doWithProject: (
    params: ProjectLoadingParameters,
    action: WithLoadedProject
) => Promise<any>;

class PushImpact

class PushImpact extends FulfillableGoalWithRegistrations<PushImpactListenerRegistration> {}

Goal that invokes PushImpactListener instances. Typically invoked early in a delivery flow.

constructor

constructor(
    goalDetailsOrUniqueName?: string | FulfillableGoalDetails,
    ...dependsOn: Goal[]
);

method withListener

withListener: (listener: PushImpactListener<any>) => this;

class PushRule

class PushRule<V = any>
    implements StaticPushMapping<V>, Predicated<PushListenerInvocation> {}

Generic DSL support for returning an object on a push

constructor

constructor(guard1: PushTest, guards: PushTest[], reason?: string);

property guard1

protected guard1: PushTest;

property guards

protected guards: PushTest[];

property name

readonly name: string;

property pushTest

readonly pushTest: PushTest;

The test for this rule

property test

readonly test: PushTest;

property value

readonly value: {};

method itMeans

itMeans: (reason: string) => this;

Set an additional reason if we want to add information to that which is available from the push tests themselves
Parameter reason
{this}

method mapping

mapping: (p: PushListenerInvocation) => Promise<V | undefined>;

method set

set: (value: V) => this;

Set the value that will be resolved from this rule
Parameter value
{this}

class PushRules

class PushRules<V>
    implements PushMapping<V>, GoalSettingStructure<PushListenerInvocation, V> {}

Use to execute a rule set for any push to resolve to an object. The value from the first matching rule will be used.

constructor

constructor(name: string, rules?: PushMapping<V>[]);

Return all possible values
Parameter name
Parameter rules
Array of rules. Passing an empty array will result in an instance that always maps to undefined, and is not an error.

property choices

choices: PushMapping<V>[];

property name

readonly name: string;

property structure

readonly structure: {
    components: Array<PushMapping<V>>;
    compositionStyle: GoalSettingCompositionStyle;
};

method add

add: (rules: Array<PushMapping<V>>) => void;

method filter

filter: (predicate: (p: PushMapping<V>) => boolean) => PushRules<V>;

Return a PushRules with a subset of the rules of this one
Parameter predicate
{PushRules}

method mapping

mapping: (pi: PushListenerInvocation) => Promise<V>;

class Queue

class Queue extends FulfillableGoal {}

Goal to queue current goal set until it is the first in the list and can execute

constructor

constructor(
    options?: FulfillableGoalDetails & QueueOptions,
    ...dependsOn: Goal[]
);

method register

register: (sdm: SoftwareDeliveryMachine) => void;

class Rename

class Rename implements Change {}

constructor

constructor(name: string, newName: string);

property how

readonly how: Mod;

property name

name: string;

property newName

newName: string;

class ReviewerError

class ReviewerError extends Error {}

constructor

constructor(reviewerName: string, msg: string, stderr: string);

property reviewerName

reviewerName: string;

property stderr

stderr: string;

class SeedDrivenGeneratorParametersSupport

class SeedDrivenGeneratorParametersSupport
    implements SeedDrivenGeneratorParameters {}

Convenient base class for project generator parameters.

constructor

constructor(config?: GeneratorConfig);

property description

readonly description: string;

property screenName

screenName: string;

property seed

seed: string;

property seedOwner

seedOwner: string;

property slackTeam

slackTeam: string;

property source

readonly source: RemoteLocator;

Resolve the seed repo {RemoteLocator}

property target

target: NewRepoCreationParameters;

property version

version: string;

class SingleProjectLoader

class SingleProjectLoader implements ProjectLoader {}

ProjectLoader that can only return one project. Normally used in testing.

constructor

constructor(project: Project);

method doWithProject

doWithProject: <T>(
    params: ProjectLoadingParameters,
    action: WithLoadedProject<T>
) => Promise<T>;

class SourceLocationGoalNameGenerator

class SourceLocationGoalNameGenerator implements GoalNameGenerator {}

Generates goal names based on source code location. This is stable enough to survive SDM restarts and also supports the cluster and goal forking mode.
This implementation has to used directly inside the body of the goal you want to name. Otherwise the source code location might not get captured correctly.

method generateName

generateName: (prefix?: string) => string;

class StringCapturingProgressLog

class StringCapturingProgressLog implements ProgressLog {}

ProgressLog implementation that captures the log into a string and makes it available from the log field

property log

log: string;

property name

readonly name: string;

property stripAnsi

stripAnsi: boolean;

method close

close: () => Promise<void>;

method flush

flush: () => Promise<void>;

method isAvailable

isAvailable: () => Promise<boolean>;

method write

write: (msg: string, ...args: string[]) => void;

class TreeContext

class TreeContext<V> {}

constructor

constructor(givenPushTests: PushTest[]);

method init

init: (f: (t: this) => any) => any;

Perform any computation necessary to initialize this branch: for example, setting variables in scope
Parameter f
{any}

method itMeans

itMeans: (name: string) => GivenTree<V>;

class WriteToAllProgressLog

class WriteToAllProgressLog implements ProgressLog {}

Write to multiple progress logs, exposing them as one.

constructor

constructor(
    name: string,
    log1: ProgressLog,
    log2: ProgressLog,
    ...others: ProgressLog[]
);

property log

readonly log: string;

property name

name: string;

property url

readonly url: string;

method close

close: () => Promise<void>;

method flush

flush: () => Promise<void>;

method isAvailable

isAvailable: () => Promise<boolean>;

method write

write: (msg: string, ...args: string[]) => void;

Interfaces

interface ActionSuggestion

interface ActionSuggestion extends EssentialGoalInfo {}

How to present a suggested goal action to the user

property format

format?: boolean;

Whether to use standard formatting for an action suggestion. Set to false to gain total control.

property message

message: string | SlackMessage;

property url

url?: string;

URL showing further information if available

interface AdminCommunicationContext

interface AdminCommunicationContext {}

Context allowing us to communicate with an admin

property addressAdmin

addressAdmin: AddressChannels;

Address the admin of this SDM

property sdm

sdm: SoftwareDeliveryMachine;

The SDM that is currently running

interface AntiPattern

interface AntiPattern {}

Antipattern we'll look for. Can be defined as a regex or a string.

property antiPattern

antiPattern: RegExp | string;

property comment

comment: string;

property name

name: string;

interface AppendOrCreateCommand

interface AppendOrCreateCommand {}

property leaveAlone

leaveAlone?: (oldContent: string) => boolean;

Custom test as to whether we should create
Parameter content
{boolean}

property path

path: string;

Path of file to create or append to

property toAppend

toAppend: string;

Content to append. Should include any whitespace required before it

interface AutoCodeInspectionOptions

interface AutoCodeInspectionOptions {}

Options to configure the behavior of the AutoCodeInspection goal.

property cloneOptions

cloneOptions?: CloneOptions;

In case more Git history is required for running the code inspection, pass appropriate CloneOptions By default only a shallow clone with depth push.commits.length + 1 is executed

property reportToSlack

reportToSlack?: boolean;

Report code inspection results to slack

interface AutofixGoalDetails

interface AutofixGoalDetails extends FulfillableGoalDetails {}

Extension to FulfillableGoalDetails to add optional TransformPresentation

property setAuthor

setAuthor?: boolean | ExtractAuthor;

Optionally set autofix commit author to author of current head commit or to the result of the provider ExtractAuthor function.

property transformPresentation

transformPresentation?: TransformPresentation<GoalInvocationParameters>;

Optional TransformPresentation to use when pushing autofix commits to repositories.

interface AutofixRegistration

interface AutofixRegistration<P = NoParameters> extends PushSelector {}

property options

options?: AutofixRegistrationOptions;

property parametersInstance

parametersInstance?: P;

Parameters used for all transforms

property transform

transform: CodeTransformOrTransforms<P>;

interface AutofixRegistrationOptions

interface AutofixRegistrationOptions {}

property ignoreFailure

ignoreFailure: boolean;

interface AutoInspectOptions

interface AutoInspectOptions {}

property cloneOptions

cloneOptions?: CloneOptions;

property listeners

listeners: ReviewListenerRegistration[];

property registrations

registrations: Array<AutoInspectRegistration<any, any>>;

property reportToSlack

reportToSlack: boolean;

interface AutoInspectRegistration

interface AutoInspectRegistration<R, PARAMS = NoParameters> extends PushSelector {}

property inspection

inspection: CodeInspection<R, PARAMS>;

Inspection function to run on each project

property parametersInstance

parametersInstance?: PARAMS;

Parameters used for all inspections

method onInspectionResult

onInspectionResult: (
    result: R,
    ci: ParametersInvocation<PARAMS>
) => Promise<PushImpactResponse | void>;

Invoked after each inspection result, if provided. A void return means keep processing this push. Return a PushImpactResponse to demand approval or fail goals.
Parameter result
Parameter ci
{Promise}

interface BuildListenerInvocation

interface BuildListenerInvocation extends RepoListenerInvocation {}

Invocation for a build on a project. Not a part of delivery control: Purely for observational purposes, such as determining the time a build took.

property build

build: Build;

Build that has just completed.

interface CacheConfiguration

interface CacheConfiguration {}

Configure a directory where files can be cached. This directory is cleaned on SDM startup; files older than 2 hours are removed.

property cache

cache?: {
    enabled?: boolean;
    /**
     * Directory defaults to /opt/data
     */
    path?: string;
};

interface CacheStats

interface CacheStats {}

property gets

gets: number;

property hits

hits: number;

interface CancelOptions

interface CancelOptions {}

Options to configure the Cancel goal

property goalFilter

goalFilter?: (goal: SdmGoalEvent) => boolean;

Filter goals to cancel based on goalSet or state
Parameter goalSet

property goalNames

goalNames?: string | string[];

Name of goals that should be canceled if they are in a state that allows cancellation

property goals

goals: Array<Goal | Goals>;

Goals that should be canceled if they are in a state that allows cancellation

interface Change

interface Change {}

property how

readonly how: Mod;

property name

readonly name: string;

interface ChannelLinkListenerInvocation

interface ChannelLinkListenerInvocation extends ProjectListenerInvocation {}

Listener invoked when a repo has been linked to a channel

property addressNewlyLinkedChannel

addressNewlyLinkedChannel: AddressChannels;

Convenient method to address the newly linked channel only. The inherited addressChannels method will address all linked channels.

property newlyLinkedChannelName

newlyLinkedChannelName: string;

interface ChildProcessOnProject

interface ChildProcessOnProject {}

Convenience access to running child processes in the context of a local project

method exec

exec: (
    cmd: string,
    args?: string | string[],
    opts?: SpawnSyncOptions
) => Promise<ExecPromiseResult>;

Spawn a child process, by default setting cwd to the directory of the local project. Any cwd passed in the options overrides the default. See [[execPromise]] for more details.
Parameter cmd
Command to spawn
Parameter args
Arguments to command
Parameter opts
Spawn options
Returns
Command standard output and standard error

method spawn

spawn: (
    cmd: string,
    args?: string | string[],
    opts?: Partial<SpawnLogOptions>
) => Promise<SpawnLogResult>;

Spawn a child process, by default setting cwd to the directory of the local project and using the progressLog of GoalInvocation as logger. Any cwd passed in the options overrides the default. See [[spawnLog]] for more details.
Parameter cmd
Command to spawn
Parameter args
Arguments to command
Parameter opts
Spawn options
Returns
Command result

interface ChooseAndSetGoalsRules

interface ChooseAndSetGoalsRules {}

Configuration for handling incoming pushes

property enrichGoal

enrichGoal?: EnrichGoal;

property goalSetter

goalSetter: GoalSetter;

property goalsListeners

goalsListeners: GoalsSetListener[];

property implementationMapping

implementationMapping: GoalImplementationMapper;

property parameterPromptFactory

parameterPromptFactory?: ParameterPromptFactory<any>;

property preferencesFactory

preferencesFactory?: PreferenceStoreFactory;

property projectLoader

projectLoader: ProjectLoader;

property repoRefResolver

repoRefResolver: RepoRefResolver;

property tagGoalSet

tagGoalSet?: TagGoalSet;

interface ClosedIssueListenerInvocation

interface ClosedIssueListenerInvocation extends IssueListenerInvocation {}

Invoked when an issue has been closed.

property issue

issue: schema.OnClosedIssue.Issue;

interface CodeInspectionActions

interface CodeInspectionActions<R, PARAMS> {}

Actions added by inspections. For internal use.

property inspection

inspection: CodeInspection<R, PARAMS>;

Inspection function to run on each project

method onInspectionResults

onInspectionResults: (
    results: Array<CodeInspectionResult<R>>,
    ci: CommandListenerInvocation<PARAMS>
) => Promise<void>;

React to computed values from running across one or more projects
Parameter results
Parameter ci
context {Promise}

interface CodeInspectionRegistration

interface CodeInspectionRegistration<R, PARAMS = NoParameters>
    extends ProjectsOperationRegistration<PARAMS>,
        CodeInspectionActions<R, PARAMS> {}

Register a AutoCodeInspection that can run against any number of projects. Include an optional react method that can react to review results.

interface CodeInspectionResult

interface CodeInspectionResult<R> {}

Result of inspecting a single project

property repoId

repoId: RepoRef;

property result

result: R | undefined;

Inspection result can be undefined if a repo was returned by an all repo query but the inspection was not run on that repo because it did not match the project predicate specified in the registration.

interface CodeTransformRegistration

interface CodeTransformRegistration<PARAMS = NoParameters>
    extends ProjectOperationRegistration<PARAMS>,
        ProjectsOperationRegistration<PARAMS> {}

Type for registering a project transform, which can make changes across projects

property transformPresentation

transformPresentation?: TransformPresentation<PARAMS>;

How to present the transformation - would you like a Pull Request or a branch commit? What would you like in the commit message, or the title of the pull request? All these and more can be specified in the EditMode, which this function can choose based on the invocation of this command and the code itself.
This defaults to a pull request with branch name derived from the transform name.

method onTransformResults

onTransformResults: (
    results: TransformResult[],
    ci: PushAwareParametersInvocation<PARAMS>
) => Promise<void>;

React to results from running transform across one or more projects

interface CommandHandlerRegistration

interface CommandHandlerRegistration<PARAMS = NoParameters>
    extends CommandRegistration<PARAMS> {}

Type for registering a project edit, which can encapsulate changes to projects. One of listener or createCommand function must be provided.

property listener

listener: CommandListener<PARAMS>;

Callback executing the command

interface CommandListenerInvocation

interface CommandListenerInvocation<PARAMS = NoParameters>
    extends ParametersInvocation<PARAMS> {}

Context for a command

property commandName

commandName: string;

property ids

ids?: RemoteRepoRef[];

The repos this command relates to, if available.

property matches

matches?: RegExpExecArray;

If the intent was a regular expression, the matches to the supplied intent are found here

method promptFor

promptFor: <NEWPARAMS>(
    parameters: ParametersDefinition<NEWPARAMS>,
    options?: ParameterPromptOptions
) => Promise<NEWPARAMS>;

Prompt for additional parameters needed during execution of the command listener.
Callers should wait for the returned Promise to resolve. It will resolve with the requested parameters if those have already been collected. If not, a parameter prompt request to the backend will be sent and the Promise will reject. Once the new parameters are collected, a new command invocation will be sent and the command listener will restart.
This requires that any state that gets created before calling promptFor can be re-created when re-entering the listener function. Also any action taken before calling promptFor needs to be implemented using idempotency patterns.

interface CommandRegistration

interface CommandRegistration<PARAMS> {}

Common supertype for all command registrations.

property autoSubmit

autoSubmit?: boolean;

Configure command to submit without confirmation

property description

description?: string;

Description of the command

property intent

intent?: string | string[] | RegExp;

Intent or list of intents. What you need to type to invoke the command, for example via the bot.

property name

name: string;

Name of the command

property parameters

parameters?: ParametersDefinition<PARAMS>;

Define parameters used by this command.

property parameterStyle

parameterStyle?: ParameterStyle;

Configure strategy on how to prompt for parameters in chat or web

property paramsMaker

paramsMaker?: Maker<PARAMS>;

Function to create a parameters object used by this command. Empty parameters will be returned by default.

property registerWhen

registerWhen?: (
    sdmConfiguration: SoftwareDeliveryMachineConfiguration
) => boolean;

If provided, select when this command is registered. Enables conditional registration on SDM startup, based on configuration, environment variables etc. This method is invoked during SDM startup.
Parameter sdmConfiguration
{boolean}

property repoFinder

repoFinder?: RepoFinder;

property repoLoader

repoLoader?: (p: PARAMS) => RepoLoader;

property tags

tags?: string | string[];

Tags associated with this command. Useful in searching.

interface CommandRegistrationManager

interface CommandRegistrationManager {}

Manage command registrations.

method addCodeInspectionCommand

addCodeInspectionCommand: <R, PARAMS = NoParameters>(
    cir: CodeInspectionRegistration<R, PARAMS>
) => this;

Add a code inspection to this machine. Unlike code transformations, code inspections cannot mutate projects. {this}

method addCodeTransformCommand

addCodeTransformCommand: <PARAMS = NoParameters>(
    ctr: CodeTransformRegistration<PARAMS>
) => this;

Add a code transformation to this machine. {this}

method addCommand

addCommand: <PARAMS = NoParameters>(
    command: CommandHandlerRegistration<PARAMS>
) => this;

Add a generic command to this machine {this}

method addGeneratorCommand

addGeneratorCommand: <PARAMS = NoParameters>(
    generator: GeneratorRegistration<PARAMS>
) => this;

Add a generator to this machine to enable project creation {this}

interface ConfigurationValues

interface ConfigurationValues {}

Options that are used during configuration of an SDM but don't get passed on to the running SDM instance

property requiredConfigurationValues

requiredConfigurationValues?: Array<
    | string
    | {
          path: string;
          type: ConfigurationValueType;
      }
>;

Optional array of required configuration value paths resolved against the root configuration

interface CredentialsResolver

interface CredentialsResolver {}

Strategy interface to resolve credentials from a handler invocation.

method commandHandlerCredentials

commandHandlerCredentials: (
    context: HandlerContext,
    id?: RemoteRepoRef
) => Promise<ProjectOperationCredentials> | ProjectOperationCredentials;

Return the appropriate credentials for this command handler invocation.
Parameter context
Parameter id
id of the repo if available {ProjectOperationCredentials}

method eventHandlerCredentials

eventHandlerCredentials: (
    context: HandlerContext,
    id?: RemoteRepoRef
) => Promise<ProjectOperationCredentials> | ProjectOperationCredentials;

Return the appropriate credentials for this event handler invocation.
Parameter context
Parameter id
id of the repo if available {ProjectOperationCredentials}

interface EndpointVerificationInvocation

interface EndpointVerificationInvocation extends RepoListenerInvocation {}

property url

url: string;

Reported endpoint base url

interface EssentialGoalInfo

interface EssentialGoalInfo extends Partial<GoalDefinition> {}

Minimum information needed to create a goal

property displayName

displayName: string;

interface EventHandlerRegistration

interface EventHandlerRegistration<EVENT = any, PARAMS = NoParameters> {}

Type for registering event handlers.

property description

description?: string;

Optional description of the event handler.

property listener

listener: OnEvent<EVENT, PARAMS>;

Listener to receive subscription matches.

property name

name: string;

Name of the event handler.

property parameters

parameters?: ParametersDefinition<PARAMS>;

Define parameters used by this event.

property paramsMaker

paramsMaker?: Maker<PARAMS>;

Create the parameters required by this event. Empty parameters will be returned by default.

property subscription

subscription: string;

GraphQL subscription to subscribe this listener to. Note: Use GraphQL.subscription() methods of automation-client to create the subscription string

property tags

tags?: string | string[];

Optional tags of the event handler.

interface EventRegistrationManager

interface EventRegistrationManager {}

Manage event registrations.

method addEvent

addEvent: <TYPE, PARAMS>(event: EventHandlerRegistration<TYPE, PARAMS>) => this;

Add an event to this machine.
Parameter event
Returns
{this}

interface EventSigningConfiguration

interface EventSigningConfiguration {}

property enabled

enabled: boolean;

Enable event signature verification on this SDM.

property events

events: string[];

Regular expressions matching subscription and mutation names to identify events that should be verified.

property signingKey

signingKey?: SigningKey<any>;

Public/Private key pair to use for event signing. The public key will also be used to verify incoming events.

property verificationKeys

verificationKeys?: VerificationKey<any> | Array<VerificationKey<any>>;

Public keys to verify incoming events

interface ExecuteGoalResult

interface ExecuteGoalResult extends GoalDetails {}

Result from goal execution.
Instead of returning ExecuteGoalResult, it is ok to throw an Error to signal errors during goal execution.

property code

code?: number;

0, undefined or null is success; non-zero exit codes will mark the goal as failed, if state is not defined

property message

message?: string;

The simple text message describing the result

interface ExplicableMapping

interface ExplicableMapping<F, V, V1 = V> extends Mapping<F, V> {}

Possible inner structure of Mapping, based on generic Mapping composition. F = input V = output V1 = output type of the structural components

property structure

structure: ExplicableMappingStructure<F, V, V1>;

interface ExplicableMappingStructure

interface ExplicableMappingStructure<F, V, V1 = V> {}

This will be a union type when we add another one

property applyFunction

applyFunction: (v: V1) => V;

property component

component: Mapping<F, V1>;

property compositionStyle

compositionStyle: MappingCompositionStyle.ApplyFunctionToOutput;

interface ExtensionPack

interface ExtensionPack
    extends MachineConfigurer,
        ExtensionPackMetadata,
        ConfigurationValues {}

Primary unit of extensibility in SDMs. Implemented to expose a capability that can be added to a software delivery machine in a consistent manner. Facilitates modularity at a higher level than FunctionUnit or handlers. For example, a Node module can export an ExtensionPack. ExtensionPacks can optional contribute goal setting, which will be added to existing goal setting.

property description

description?: string;

Human-readable description of this extension pack

property goalContributions

goalContributions?: GoalSetter;

Optional goal setting contributions that will be added into SDM goal setting. Decorates other goal setting behavior.

interface ExtensionPackMetadata

interface ExtensionPackMetadata {}

property name

name: string;

Name of the extension pack

property tags

tags?: string | string[];

Optional tags of extension pack

property vendor

vendor: string;

Vendor or author of this extension pack

property version

version: string;

Version of extension pack

interface FileGlobMapping

interface FileGlobMapping {}

property globPatterns

globPatterns: string[];

See https://github.com/gulpjs/glob-stream for implementation details

property recipientPath

recipientPath?: string;

This recipientPath will only be prefixed verbatim to any path returned from the globs.

interface FileMapping

interface FileMapping {}

property donorPath

donorPath: string;

property recipientPath

recipientPath: string;

interface FulfillableGoalDetails

interface FulfillableGoalDetails {}

Subset of the GoalDefinition interface to use by typed Goals to allow specifying some aspect of the Goal that are specific to the current use case.

property approval

approval?: boolean;

property descriptions

descriptions?: {
    planned?: string;
    requested?: string;
    completed?: string;
    inProcess?: string;
    failed?: string;
    waitingForApproval?: string;
    waitingForPreApproval?: string;
    canceled?: string;
    stopped?: string;
};

property displayName

displayName?: string;

property environment

environment?: string | GoalEnvironment;

property isolate

isolate?: boolean;

property preApproval

preApproval?: boolean;

property preCondition

preCondition?: WaitRules;

property retry

retry?: boolean;

property retryCondition

retryCondition?: RetryOptions;

property uniqueName

uniqueName?: string;

interface FulfillmentRegistration

interface FulfillmentRegistration {}

property name

name: string;

Name of goal implementation

property pushTest

pushTest?: PushTest;

Optional push test to identify the types of projects and pushes this implementation should get invoked on when the goal gets scheduled

interface FunctionalUnit

interface FunctionalUnit {}

Unit of functionality that can be added to an Atomist automation.

property commandHandlers

readonly commandHandlers: Array<Maker<HandleCommand>>;

property eventHandlers

readonly eventHandlers: Array<Maker<HandleEvent<any>>>;

property ingesters

readonly ingesters: string[];

interface GeneratorConfig

interface GeneratorConfig {}

Basic config for all parameter creation

property seed

seed: () => RemoteRepoRef;

The seed repo

interface GeneratorRegistration

interface GeneratorRegistration<PARAMS = NoParameters>
    extends ProjectOperationRegistration<PARAMS, SeedDrivenGeneratorParameters> {}

property afterAction

afterAction?:
    | ProjectAction<PARAMS & SeedDrivenGeneratorParameters>
    | Array<ProjectAction<PARAMS & SeedDrivenGeneratorParameters>>;

Hooks that get executed after a successful project generation. Note: these hooks fire after the project has been generated and pushed to the remote repository.

property fallbackTarget

fallbackTarget?: Maker<RepoCreationParameters>;

Allow customization of the target for this repo, e.g. to target a different source control system.

property projectPersister

projectPersister?: ProjectPersister;

Strategy for persisting projects. Useful in testing.

property startingPoint

startingPoint?: StartingPoint<PARAMS>;

Starting point before transformation. Normally the coordinates of a seed project, but can also be in memory. The alternative is to get this from a config object.

interface GitHubStatus

interface GitHubStatus {}

property context

context?: GitHubStatusContext;

property description

description?: string;

property state

state?: StatusState;

property targetUrl

targetUrl?: string;

interface GitHubStatusAndFriends

interface GitHubStatusAndFriends extends GitHubStatus {}

property siblings

siblings: GitHubStatus[];

interface GoalApprovalRequestVoteResult

interface GoalApprovalRequestVoteResult {}

Result from executing GoalApprovalRequestVoter

property reason

reason?: string;

Optional text describing why the decision was being made

property vote

vote: GoalApprovalRequestVote;

The vote

interface GoalApprovalRequestVoterInvocation

interface GoalApprovalRequestVoterInvocation extends RepoContext {}

Invocation of a GoalApprovalRequestVoter

property goal

goal: SdmGoalEvent;

Goal that was requested for approval

interface GoalCompletionListenerInvocation

interface GoalCompletionListenerInvocation extends RepoListenerInvocation {}

Invocation on goal that has succeeded or failed. This could come from any SDM. GoalExecutionListener focuses only on goals from the present SDM.

property allGoals

allGoals: SdmGoalEvent[];

property completedGoal

completedGoal: SdmGoalEvent;

interface GoalContribution

interface GoalContribution<F> extends Mapping<F, GoalComponent>, Predicated<F> {}

interface GoalDefinition

interface GoalDefinition {}

Core data for a goal

property approvalRequired

approvalRequired?: boolean;

property canceledDescription

canceledDescription?: string;

property completedDescription

completedDescription?: string;

property displayName

displayName?: string;

property environment

environment?: GoalEnvironment;

Optional environment for this goal to run in. This is meant to allow for logical grouping of goals from code, testing and production etc.

property failedDescription

failedDescription?: string;

property isolated

isolated?: boolean;

property plannedDescription

plannedDescription?: string;

property preApprovalRequired

preApprovalRequired?: boolean;

property requestedDescription

requestedDescription?: string;

property retryFeasible

retryFeasible?: boolean;

property skippedDescription

skippedDescription?: string;

property stoppedDescription

stoppedDescription?: string;

property uniqueName

uniqueName: string;

Must be unique among goals Should be camel case

property waitingForApprovalDescription

waitingForApprovalDescription?: string;

property waitingForPreApprovalDescription

waitingForPreApprovalDescription?: string;

property workingDescription

workingDescription?: string;

interface GoalDetails

interface GoalDetails {}

Result from goal execution with additional details that will be persisted on the currently executing goal.

property data

data?: string;

Update the goals data field

property description

description?: string;

Optional description to be set on the goal

property externalUrls

externalUrls?: Array<{
    label?: string;
    url: string;
}>;

Optional externalUrls to be set on the goal

property phase

phase?: string;

Optional phase to return from the goal execution

property state

state?: SdmGoalState;

Optional state for the goal

interface GoalDrivenMachine

interface GoalDrivenMachine<O extends SoftwareDeliveryMachineConfiguration>
    extends MachineConfiguration<O> {}

Interface for machines driven by configurable goals. Goals and goal "implementations" can be defined by users.

property goalFulfillmentMapper

readonly goalFulfillmentMapper: GoalImplementationMapper;

property pushMapping

pushMapping: PushMapping<Goals>;

Return the PushMapping that will be used on pushes. Useful in testing goal setting. {PushMapping}

method addGoalApprovalRequestVoter

addGoalApprovalRequestVoter: (vote: GoalApprovalRequestVoter) => this;

Add vote that gets to decide whether to deny or grant goal approval requests.
Parameter vote

method addGoalContributions

addGoalContributions: (
    goalContributions: GoalSetter<PushListenerInvocation>
) => this;

(hint: prefer withPushRules)
Add goal setting contributions that will be added into SDM goal setting. Decorates other goal setting behavior.
For example, always do fingerprints: sdm.addGoalContributions(onAnyPush().setGoals(FingerprintGoal))
Or, sometimes do a custom local deploy goal: sdm.addGoalContributions( whenPushSatisfies(IsSdm, IsInLocalMode).setGoals( new Goals("delivery", LocalSdmDelivery)));
Parameter goalContributions
contributions to goals

method setGoalApprovalRequestVoteDecisionManager

setGoalApprovalRequestVoteDecisionManager: (
    manager: GoalApprovalRequestVoteDecisionManager
) => this;

Set the decision manager used to make final decision on GoalApprovalRequestVoteResult instances.
Parameter manager

method withPushRules

withPushRules: <F extends SdmContext = PushListenerInvocation>(
    contributor: GoalContribution<F>,
    ...contributors: Array<GoalContribution<F>>
) => this;

Add to the list of things an SDM can do on a push.
Parameter contributor
contributor to set
Parameter contributors
additional contributors

interface GoalExecutionListenerInvocation

interface GoalExecutionListenerInvocation extends RepoListenerInvocation {}

Invokes when an event occurs relating to execution of a goal within this SDM.

property error

error?: Error;

Error that was raised during goal execution if not handled inside the goalExecutor

property goal

goal: Goal;

The goal that is current executing

property goalEvent

goalEvent: SdmGoalEvent;

The goal event that changed state

property result

result?: ExecuteGoalResult | undefined;

Result of goal execution; only available if goalExecutor returned an result

interface GoalFulfillmentCallback

interface GoalFulfillmentCallback {}

Callback to allow changes to the goal before it gets fullfilled.
This is useful to add goal specific information to the data field.

property callback

callback: (goal: SdmGoalEvent, context: RepoContext) => Promise<SdmGoalEvent>;

property goal

goal: Goal;

interface GoalImplementation

interface GoalImplementation {}

property goal

goal: Goal;

property goalExecutor

goalExecutor: ExecuteGoal;

property implementationName

implementationName: string;

property logInterpreter

logInterpreter: InterpretLog;

property progressReporter

progressReporter?: ReportProgress;

property projectListeners

projectListeners:
    | GoalProjectListenerRegistration
    | GoalProjectListenerRegistration[];

property pushTest

pushTest: PushTest;

interface GoalImplementationMapper

interface GoalImplementationMapper {}

Registers and looks up goal implementations

method addFulfillmentCallback

addFulfillmentCallback: (callback: GoalFulfillmentCallback) => this;

method addSideEffect

addSideEffect: (sideEffect: GoalSideEffect) => this;

method findFulfillmentByPush

findFulfillmentByPush: (
    goal: Goal,
    inv: PushListenerInvocation
) => Promise<GoalFulfillment | undefined>;

method findFulfillmentCallbackForGoal

findFulfillmentCallbackForGoal: (g: SdmGoalEvent) => GoalFulfillmentCallback[];

method findGoalBySdmGoal

findGoalBySdmGoal: (g: SdmGoalEvent) => Goal | undefined;

method findImplementationBySdmGoal

findImplementationBySdmGoal: (goal: SdmGoalEvent) => GoalImplementation;

method hasImplementation

hasImplementation: () => boolean;

interface GoalInvocation

interface GoalInvocation extends RepoContext, Parameterized {}

property configuration

configuration: SoftwareDeliveryMachineConfiguration;

This SDM's current configuration

property goal

goal: Goal;

The goal that we are currently executing

property goalEvent

goalEvent: SdmGoalEvent;

The goal event that triggered this execution

property progressLog

progressLog: ProgressLog;

Progress log to write output to
Use this to write user-level log messages that you want to see in the log stream

interface GoalInvocationParameters

interface GoalInvocationParameters {}

Parameters that includes the current GoalInvocation

property goalInvocation

goalInvocation: GoalInvocation;

Current goal invocation the autofixes are running

interface GoalNameGenerator

interface GoalNameGenerator {}

Strategy for generating goal unique names

method generateName

generateName: (prefix?: string) => string;

Generate the name based on given optional prefix
Parameter prefix

interface GoalProjectListenerRegistration

interface GoalProjectListenerRegistration {}

property events

events?: GoalProjectListenerEvent[];

property listener

listener: GoalProjectListener;

property name

name: string;

property pushTest

pushTest?: PushTest;

interface GoalsAndPreConditionBuilder

interface GoalsAndPreConditionBuilder extends GoalsBuilder {}

Extension to GoalsBuilder allowing to add preConditions.

method after

after: (...goals: Array<Goals | GoalDefinition | Goal>) => Goals & GoalsBuilder;

Add preCondition(s) to previously planned goal or goals. Note: This only will affect the goal or goals that were planned immediately before calling after. Only call this once; an additional call will remove other preconditions that may have existed on the original goal.
Parameter goals
Returns
{Goals & GoalsBuilder}

interface GoalsBuilder

interface GoalsBuilder {}

Builder to build Goals instances.

method plan

plan: (
    ...goals: Array<GoalDefinition | Goal | Goals>
) => Goals & GoalsAndPreConditionBuilder;

Plan the given goal or goals to this Goals instance.
Parameter goals
Returns
{Goals & GoalsAndPreConditionBuilder}

interface GoalScheduler

interface GoalScheduler {}

Schedule a goal in an environment (container or process) for fulfillment.

method initialize

initialize: (configuration: Configuration) => Promise<void>;

Optionally initialize the GoalScheduler
Parameter configuration

method schedule

schedule: (gi: GoalInvocation) => Promise<ExecuteGoalResult>;

Schedule the provided goal
Parameter gi

method supports

supports: (gi: GoalInvocation) => Promise<boolean>;

Indicate if this GoalScheduler supports scheduling provided goal
Parameter gi

interface GoalSetTag

interface GoalSetTag {}

property name

name: string;

property value

value?: string;

interface GoalSettingStructure

interface GoalSettingStructure<F, V> extends Mapping<F, V> {}

Some (composed) mappings contain information about their internal structure.
It only extends Mapping<F,V> because it's expected to apply only to those

property structure

structure: {
    compositionStyle: GoalSettingCompositionStyle;
    components: Array<Mapping<F, V>>;
};

interface GoalSideEffect

interface GoalSideEffect {}

Information needed to create a goal side effect.

property goal

goal: Goal;

Goal on which to associated the side effect.

property pushTest

pushTest?: PushTest;

Push test that when true the side effect will be triggered. If not provided, [[AnyPush]] is used.

property registration

registration?: string;

Name of SDM executing side effect. If not provided, the current SDM registration name will be used.

property sideEffectName

sideEffectName: string;

Name of goal side effect. It should be unique.

interface GoalSigningAlgorithm

interface GoalSigningAlgorithm<T> {}

Strategy for implementing different signature algorithms

property name

name: string;

Return the name of this algorithm

method sign

sign: (goal: SdmGoalMessage, key: SigningKey<T>) => Promise<string>;

Sign the provided goal with the given key

method verify

verify: (
    goal: SdmGoalEvent,
    signature: string,
    key: VerificationKey<T>
) => Promise<SdmGoalEvent>;

Verify the provided goal against the signature

interface GoalSigningConfiguration

interface GoalSigningConfiguration {}

property algorithms

algorithms?: GoalSigningAlgorithm<any> | Array<GoalSigningAlgorithm<any>>;

Algorithms to use for signing and verification
Default RSA-SHA512 algorithm will always be available

property enabled

enabled: boolean;

Enable goal signature verification on this SDM.

property scope

scope: GoalSigningScope;

Scope for goal signing:
Fulfillment: only verify goals before fulfillment All: verify goals during all phases of a goal set execution

property signingKey

signingKey?: SigningKey<any>;

Public/Private key pair to use for goal signing. The public key will also be used to verify incoming goals.

property verificationKeys

verificationKeys?: VerificationKey<any> | Array<VerificationKey<any>>;

Public keys to verify incoming goals

interface GoalsSetListenerInvocation

interface GoalsSetListenerInvocation extends RepoListenerInvocation {}

Invokes when goals have been set

property goalSet

goalSet: Goals | null;

The goals that were set

property goalSetId

goalSetId: string;

The id of the goal set

property goalSetName

goalSetName: string;

The name of the goal set

property push

push: PushFields.Fragment;

The Push that the triggered scheduling of these goals

interface GoalTest

interface GoalTest extends PushTest {}

Extension to PushTest to pre-condition on SDM goal events, so called GoalTests

property pushTest

pushTest: PushTest;

interface HasChannels

interface HasChannels {}

Interface for anything, like a repo, that has associated chat channel information

property channels

channels?: Array<{
    name?: string;
    id?: string;
    team?: {
        id?: string;
    };
}>;

interface HasDefaultValue

interface HasDefaultValue {}

Interface mixed in with BaseParameter to allow adding a default value to a parameter. When the class-style decorated approach is used, this is unnecessary as any field value will be used as a default.

property defaultValue

defaultValue?: any;

interface Implementation

interface Implementation extends ImplementationRegistration {}

property goalExecutor

goalExecutor: ExecuteGoal;

interface ImplementationRegistration

interface ImplementationRegistration extends FulfillmentRegistration {}

property logInterpreter

logInterpreter?: InterpretLog;

Optional log interpreter for this goal implementations log output

property progressReporter

progressReporter?: ReportProgress;

Optional progress reporter for this goal implementation

interface IngesterRegistration

interface IngesterRegistration {}

Type to register customer type ingesters.

property ingester

ingester: string;

Ingester GraphQL SDL Note: use the ingester() method of automation-client to load the ingester graphql contents.

interface IngesterRegistrationManager

interface IngesterRegistrationManager {}

Manage ingester registrations.

method addIngester

addIngester: (ingester: string | IngesterRegistration) => this;

Add ingester to this machine.
Parameter ingester
Returns
{this}

interface InterpretedLog

interface InterpretedLog<D = any> {}

Log from which we've been able to glean further information D type of additional structured data, if available

property data

data?: D;

Additional structured information from the log, if specified

property doNotReportToUser

doNotReportToUser?: boolean;

Set to true only if we should not bother to report this log to the user

property includeFullLog

includeFullLog?: boolean;

Should the UX include the full log, or is it too long or ugly?

property message

message: string;

property relevantPart

relevantPart: string;

Relevant part of log to display in UX, if we were able to identify it

interface IssueCreationOptions

interface IssueCreationOptions {}

Options for anything that can raise issues.

property issueRouter

issueRouter: IssueRouter;

interface IssueListenerInvocation

interface IssueListenerInvocation extends RepoListenerInvocation {}

Superinterface for new and updated and closed issue invocations.

property issue

issue: schema.OnIssueAction.Issue;

interface IssueRouter

interface IssueRouter {}

Implemented by types that can raise issues

method raiseIssue

raiseIssue: (
    credentials: ProjectOperationCredentials,
    id: RemoteRepoRef,
    issue: Issue
) => Promise<void>;

Raise an issue with the given routing strategy.
Parameter credentials
Parameter id
Parameter issue
{Promise}

interface JobDetails

interface JobDetails<T extends ParameterType> {}

Details of the job to create

property command

command: string | CommandRegistration<T>;

property concurrentTasks

concurrentTasks?: number;

Optional maximum number of concurrent tasks; defaults to running all tasks in parallel

property description

description?: string;

property name

name?: string;

property parameters

parameters: T | T[];

property registration

registration?: string;

interface JobTask

interface JobTask<T extends ParameterType> {}

property parameters

parameters: T;

property type

type: JobTaskType;

interface LazyProject

interface LazyProject {}

method materialize

materialize: () => Promise<GitProject>;

method materialized

materialized: () => boolean;

interface LazyProjectLoader

interface LazyProjectLoader extends ProjectLoader {}

Marker interface to declare a ProjectLoader to lazily load projects

property isLazy

isLazy: true;

This project loader is always lazy

method doWithProject

doWithProject: <T>(
    params: ProjectLoadingParameters,
    action: WithLoadedLazyProject<T>
) => Promise<T>;

Perform an action with the given project

interface ListenerRegistrationManager

interface ListenerRegistrationManager {}

Listener management offering a fluent builder pattern for registrations.

property channelLinkListeners

readonly channelLinkListeners: ReadonlyArray<ChannelLinkListener>;

property closedIssueListeners

readonly closedIssueListeners: ReadonlyArray<ClosedIssueListener>;

property firstPushListeners

readonly firstPushListeners: ReadonlyArray<PushListener>;

property goalCompletionListeners

readonly goalCompletionListeners: ReadonlyArray<GoalCompletionListener>;

property goalExecutionListeners

readonly goalExecutionListeners: ReadonlyArray<GoalExecutionListener>;

property goalsSetListeners

readonly goalsSetListeners: ReadonlyArray<GoalsSetListener>;

property newIssueListeners

readonly newIssueListeners: ReadonlyArray<NewIssueListener>;

property pullRequestListeners

readonly pullRequestListeners: ReadonlyArray<PullRequestListener>;

property repoCreationListeners

readonly repoCreationListeners: ReadonlyArray<RepoCreationListener>;

property repoOnboardingListeners

readonly repoOnboardingListeners: ReadonlyArray<ProjectListener>;

property startupListeners

readonly startupListeners: ReadonlyArray<StartupListener>;

property tagListeners

readonly tagListeners: ReadonlyArray<TagListener>;

property updatedIssueListeners

readonly updatedIssueListeners: ReadonlyArray<UpdatedIssueListener>;

property userJoiningChannelListeners

readonly userJoiningChannelListeners: ReadonlyArray<UserJoiningChannelListener>;

method addChannelLinkListener

addChannelLinkListener: (l: Function1<I, Promise<R>>) => this;

Add a listener that will be invoked when a channel is linked to a repo
Parameter l

method addClosedIssueListener

addClosedIssueListener: (l: Function1<I, Promise<R>>) => this;

method addFirstPushListener

addFirstPushListener: (pl: Function1<I, Promise<R>>) => this;

Register a listener that reacts to a new repo appearing with content. The invocation's addressChannels will DM the creator of the project if possible, as any channel mapping will not have been set up.
Parameter pl
{this}

method addGoalCompletionListener

addGoalCompletionListener: (l: Function1<I, Promise<R>>) => this;

method addGoalExecutionListener

addGoalExecutionListener: (l: Function1<I, Promise<R>>) => this;

Invoked when a goal state changes to in-process, success, or failure.
Returns
{this}

method addGoalsSetListener

addGoalsSetListener: (l: Function1<I, Promise<R>>) => this;

method addNewIssueListener

addNewIssueListener: (l: Function1<I, Promise<R>>) => this;

Add a listener that reacts to new issues
Parameter l
{this}

method addPullRequestListener

addPullRequestListener: (prl: Function1<I, Promise<R>>) => this;

method addRepoCreationListener

addRepoCreationListener: (rcl: Function1<I, Promise<R>>) => this;

You probably mean to use addFirstPushListener! This responds to a repo creation, but there may be no code in it. The invocation's addressChannels method with have no effect: use the context if you want to send messages
Parameter rcl
{this}

method addRepoOnboardingListener

addRepoOnboardingListener: (l: Function1<I, Promise<R>>) => this;

method addStartupListener

addStartupListener: (
    l: Function1<AdminCommunicationContext, Promise<void>>
) => this;

Add a listener that will be notified of machine startup
Parameter l
{this}

method addTagListener

addTagListener: (l: Function1<I, Promise<R>>) => this;

method addTriggeredListener

addTriggeredListener: (t: TriggeredListenerRegistration) => this;

Add a listener that gets invoked on time-based triggers
Parameter t
{this}

method addUpdatedIssueListener

addUpdatedIssueListener: (l: Function1<I, Promise<R>>) => this;

method addUserJoiningChannelListener

addUserJoiningChannelListener: (l: Function1<I, Promise<R>>) => this;

interface LogInterpretation

interface LogInterpretation {}

Implemented by types that have the ability to interpret the logs they generate

property logInterpreter

logInterpreter: InterpretLog;

interface MachineConfiguration

interface MachineConfiguration<O> {}

Configuration for software delivery machines

property configuration

readonly configuration: Configuration & O;

Automation client and machine configuration this machine will run in

property name

readonly name: string;

interface MachineConfigurer

interface MachineConfigurer {}

Extended by types that know how to configure an existing SDM. The SDM's configuration will be valid and can be accessed in the implementation of the configure method.

property configure

configure: ConfigureMachine;

Function to configure the given SDM
Parameter sdm

interface MappedParameterOrSecretDeclaration

interface MappedParameterOrSecretDeclaration {}

property declarationType

declarationType: DeclarationType;

property required

required?: boolean;

Only valid on mapped parameters

property uri

uri: string;

interface Mapping

interface Mapping<F, V> {}

Mapper from source to value, if it can be resolved. This is a central interface used throughout the SDM.

property mapping

mapping: Mapper<F, V>;

Compute a value for the given event. Return undefined if we don't find a mapped value. Return DoNotSetAnyGoals (null) to shortcut evaluation of the present set of rules, terminating evaluation and guarantee the return of undefined if we've reached this point. Only do so if you are sure that this evaluation must be short circuited if it has reached this point. If a previous rule has matched, it will still be used. The value may be static or computed on demand, depending on the implementation.

property name

readonly name: string;

Name of the Mapping. Must be unique

interface MaterialChangeOptions

interface MaterialChangeOptions {}

Options to pass to the IsMaterialChange push test

property directories

directories?: string[];

Directory paths to watch for Note: This matches on subdirectories

property extensions

extensions?: string[];

File extensions to watch for

property files

files?: string[];

File paths to watch for

property globs

globs?: string[];

Glob patters to watch for

interface MockGoal

interface MockGoal {}

Options to configure mocks for one particular goal

property goal

goal: Goal;

property mock

mock?: ExecuteGoal;

property result

result?: number;

property size

size: MockGoalSize | number;

interface MockOptions

interface MockOptions {}

Options for the mock goal executor support

property defaultSize

defaultSize?: MockGoalSize | number;

property enabled

enabled: boolean | ((goal: SdmGoalEvent) => boolean);

property goals

goals?: MockGoal[];

property randomBy

randomBy?: number;

interface NamedMappedParameter

interface NamedMappedParameter {}

property name

name: string;

property required

required?: boolean;

property uri

uri: string;

interface NamedSecret

interface NamedSecret {}

property name

name: string;

property uri

uri: string;

interface NamedValueParameter

interface NamedValueParameter extends BaseValue {}

property name

name: string;

interface NewIssueListenerInvocation

interface NewIssueListenerInvocation extends IssueListenerInvocation {}

property issue

issue: schema.OnIssueAction.Issue;

interface Parameterized

interface Parameterized {}

property parameters

parameters?: DefaultFacts;

interface ParameterPromptOptions

interface ParameterPromptOptions {}

Options to configure the parameter prompt

property autoSubmit

autoSubmit?: boolean;

Configure auto submit strategy for when all required parameters are collected

property parameterStyle

parameterStyle?: ParameterStyle;

Configure strategy on how to ask for parameters in chat or web

property thread

thread?: boolean | string;

Optional thread identifier to send this message to or true to send this to the message that triggered this command.

interface ParametersInvocation

interface ParametersInvocation<PARAMS> extends SdmContext {}

Context for anything with parameters. All commands have parameters, as do autofixes and auto inspections.

property parameters

parameters?: PARAMS;

Parameters, if any were supplied

interface ParametersListing

interface ParametersListing {}

Define parameters used in a command

property mappedParameters

readonly mappedParameters: NamedMappedParameter[];

property parameters

readonly parameters: NamedParameter[];

property secrets

readonly secrets: NamedSecret[];

property values

readonly values: NamedValue[];

interface PatternMatchReviewerOptions

interface PatternMatchReviewerOptions {}

property category

category?: string;

property globPattern

globPattern: string;

Glob pattern for files to check

property pushTest

pushTest?: PushTest;

PushTest to narrow review applicability

property severity

severity?: Severity;

property subcategory

subcategory?: string;

interface PlannableGoal

interface PlannableGoal {}

method plan

plan: (
    pli: StatefulPushListenerInvocation,
    goals: Goals
) => Promise<PlannedGoals | PlannedGoal>;

interface PlannedGoal

interface PlannedGoal extends Parameterized {}

property details

details?: Omit<FulfillableGoalDetails, 'uniqueName' | 'environment'>;

property fulfillment

fulfillment?: {
    registration: string;
    name: string;
};

interface Predicated

interface Predicated<F> {}

Implemented by types whose behavior is potentially explicable by a single PredicateMapping

property test

test?: PredicateMapping<F>;

The test for the contribution. Contributions may be applied in various ways.

interface PredicatedGoalDefinition

interface PredicatedGoalDefinition extends GoalDefinition {}

Extension to GoalDefinition that allows to specify additional WaitRules.

property preCondition

preCondition?: WaitRules;

property retryCondition

retryCondition?: RetryOptions;

interface PredicateMapping

interface PredicateMapping<F> extends Mapping<F, boolean> {}

Mapping to a boolean

property structure

readonly structure?: {
    components: Array<PredicateMapping<F>>;
    readonly compositionStyle: PredicateMappingCompositionStyle;
};

If this predicate has internal structure, the components and how they are applied. For internal and tooling use.

interface PredicatePushTest

interface PredicatePushTest extends PushTest {}

PushTest that also exposes the ProjectPredicate it is based on

property predicate

predicate: ProjectPredicate;

interface PreferenceStore

interface PreferenceStore {}

Strategy to store and retrieve SDM preferences.

method delete

delete: (
    key: string,
    options?: { scope?: PreferenceScope | string }
) => Promise<void>;

Delete a preference in a given scope

method get

get: <V>(
    key: string,
    options?: { scope?: PreferenceScope | string; defaultValue?: V }
) => Promise<V | undefined>;

Retrieve a preference object via its key in the given scope.

method list

list: <V>(
    scope: PreferenceScope | string
) => Promise<Array<{ key: string; value: V }>>;

List all preferences in a given scope

method put

put: <V>(
    key: string,
    value: V,
    options?: { scope?: PreferenceScope | string; ttl?: number }
) => Promise<V>;

Store a preference object with the specified ttl and scope.

interface Progress

interface Progress {}

Signals a certain phase was entered during Goal execution.

property phase

phase?: string;

Simple string label indicating the phase

interface ProgressLog

interface ProgressLog extends WritableLog {}

Log abstraction for output of a specific activity. Not intended as a long-running log but for a short-lived activity. Not a technical log of this project but a log of meaningful activity on behalf of users.

property name

readonly name: string;

Name. Should relate to the immediate activity we're logging.

property url

readonly url?: string;

Return the url of the log if it is persisted

method close

close: () => Promise<void>;

method flush

flush: () => Promise<void>;

method isAvailable

isAvailable: () => Promise<boolean>;

Is this logger available at this point in time? E.g. if it's backed by a service, is that service up?

method write

write: (log: string, ...args: any[]) => void;

Function that appends to the log.

interface ProgressTest

interface ProgressTest {}

Simple test to map between a RegExp and a phase.

property phase

phase: string;

property test

test: RegExp;

interface ProjectListenerInvocation

interface ProjectListenerInvocation extends RepoListenerInvocation {}

Invocation for an event on a project

property project

project: GitProject;

The project to which this event relates. It will have been cloned prior to this invocation. Modifications made during listener invocation will not be committed back to the project (although they are acceptable if necessary, for example to run particular commands against the project). As well as working with project files using the Project superinterface, we can use git-related functionality fro the GitProject subinterface: For example to check for previous shas. We can also easily run shell commands against the project using its baseDir.

interface ProjectLoader

interface ProjectLoader {}

Common interface for project loading that allows caching etc.

method doWithProject

doWithProject: <T>(
    params: ProjectLoadingParameters,
    action: WithLoadedProject<T>
) => Promise<T>;

Perform an action with the given project
Parameter params
Parameter action

interface ProjectLoadingParameters

interface ProjectLoadingParameters {}

property cloneDir

cloneDir?: string;

Explicitly configured target clone dir

property cloneOptions

cloneOptions?: CloneOptions;

property context

context?: HandlerContext;

property credentials

credentials: ProjectOperationCredentials;

property id

id: RemoteRepoRef;

property readOnly

readOnly: boolean;

Return true to get optimized behavior for read only

interface PullRequestListenerInvocation

interface PullRequestListenerInvocation extends ProjectListenerInvocation {}

Invocation for a pull request. The project will be as of the sha of the head of the pull request

property pullRequest

pullRequest: OnPullRequest.PullRequest;

interface PushAwareParametersInvocation

interface PushAwareParametersInvocation<P> extends ParametersInvocation<P> {}

Code inspections or autofixes may be invoked in response to a push, or just with Parameters

property progressLog

progressLog?: ProgressLog;

Optional ProgressLog to log to

property push

push?: PushImpactListenerInvocation;

The push invocation. Will be undefined if we are not invoked from a push.

interface PushImpactListenerInvocation

interface PushImpactListenerInvocation extends PushListenerInvocation {}

Invocation object used by most listeners that react to code changes. Provides fuller information about the impact of the push.

property commit

commit: PushFields.Commits;

Head commit on push

property filesChanged

filesChanged: string[] | undefined;

Paths of the files changed in this push. Undefined if it is unknown how many files have changed.

property impactedSubProject

impactedSubProject: Project;

Project of affected files. May be the same as project, if we can't tell which files were affected.

interface PushListenerInvocation

interface PushListenerInvocation extends ProjectListenerInvocation {}

Invocation for an event relating to a push on a project. Many event listeners listen to this type of event.

property push

readonly push: OnPushToAnyBranch.Push;

Information about the push, including repo and commit

interface PushMapping

interface PushMapping<V> extends Mapping<PushListenerInvocation, V> {}

Mapper from push to value, id it can be resolved. This is a central interface used throughout the SDM.

interface PushRegistration

interface PushRegistration<A> extends PushSelector {}

Superclass for registering actions or listeners associated with a push

property action

action: A;

interface PushSelector

interface PushSelector {}

Extended by any object that can react to a subset of pushes.

property name

name: string;

property pushTest

pushTest?: PushTest;

interface PushTest

interface PushTest extends PredicateMapping<StatefulPushListenerInvocation> {}

Special PushMapping. Return true if we like this push. Used in goal setting etc.

interface QueueOptions

interface QueueOptions {}

Options to configure the Queue goal

property concurrent

concurrent?: number;

property fetch

fetch?: number;

interface Registerable

interface Registerable {}

method register

register: (sdm: SoftwareDeliveryMachine) => void;

interface RepoContext

interface RepoContext extends SdmContext {}

Context for an SDM action on a particular repo

property id

id: RemoteRepoRef;

The repo this relates to

interface RepoCreationListenerInvocation

interface RepoCreationListenerInvocation extends RepoListenerInvocation {}

Superinterface for all event invocations concerning a repo. Note: addressChannels will not result in any output on this event as any channel mapping will not have been set up.

property repo

repo: schema.OnRepoCreation.Repo;

interface RepoRefResolver

interface RepoRefResolver {}

Resolve a RemoteRepoRef from data in our model

method providerIdFromPush

providerIdFromPush: (push: OnPushToAnyBranch.Push) => string | null;

method repoRefFromPush

repoRefFromPush: (push: OnPushToAnyBranch.Push) => RemoteRepoRef;

Obtain a RemoteRepoRef from the given push, correctly resolving provider.
Parameter push
{any}

method repoRefFromSdmGoal

repoRefFromSdmGoal: (
    sdmGoal: SdmGoalEvent,
    provider?: ScmProvider.ScmProvider
) => RemoteRepoRef;

get a repoRef from an SdmGoal.
Parameter sdmGoal
Parameter provider
: No longer needed; the SdmGoalEvent now contains this information
Returns
{RemoteRepoRef}

method toRemoteRepoRef

toRemoteRepoRef: (
    repo: CoreRepoFieldsAndChannels.Fragment,
    opts: { sha?: string; branch?: string }
) => RemoteRepoRef;

Convert GraphQL return to our remote repo ref, instantiating the correct type based on provider
Parameter repo
Parameter opts
options - sha or branch {RemoteRepoRef}

interface RepoTargetingParameters

interface RepoTargetingParameters {}

property targets

targets: RepoTargets;

interface RepoTargets

interface RepoTargets {}

Defines repo targeting for a code inspection or transform

property credentials

credentials: ProjectOperationCredentials;

property repoRef

repoRef: RemoteRepoRef;

Single repo ref we're targeting if there is one

property test

test: RepoFilter;

Is this repo eligible
Parameter id
{boolean}

method bindAndValidate

bindAndValidate: () => ValidationResult;

Optional method to populate and validate

interface ReviewerRegistration

interface ReviewerRegistration<PARAMS = NoParameters>
    extends AutoInspectRegistration<ProjectReview, PARAMS> {}

interface ReviewListenerInvocation

interface ReviewListenerInvocation extends PushListenerInvocation {}

Invocation on a completed review.

property review

review: ProjectReview;

Consolidated review

interface ReviewListenerRegistration

interface ReviewListenerRegistration {}

property listener

listener: ReviewListener;

property name

name: string;

interface SdmContext

interface SdmContext {}

Context for an SDM action, whether a listener invocation or internal action

property addressChannels

addressChannels: AddressChannels;

Provides a way to address the channel(s) related to this action: usually, an event or command invocation. In an event handler, these are usually the channel(s) linked to a repo. In a command handler, the behavior will be the same as that of MessageClient.respond. In some cases, such as repo creation or a push to a repo where there is no linked channel, addressChannels will go to dev/null without error.

property configuration

configuration: Configuration;

property context

context: HandlerContext;

Context of the Atomist EventHandler invocation. Use to run GraphQL queries, use the messageClient directly and find the team and correlation id

property credentials

credentials: ProjectOperationCredentials;

Credentials for use with source control hosts such as GitHub

property preferences

preferences: PreferenceStore;

Store and retrieve preferences for this SDM or team

property skill

skill: SkillContext;

interface SdmGoalEvent

interface SdmGoalEvent extends SdmGoalKey {}

An SdmGoal event.
After https://github.com/atomisthq/automation-api/issues/479 is fixed, and we make the required fields NonNull in GraphQL, change this to be a type alias for SdmGoalFields.Fragment.

property approval

approval?: SdmProvenance;

property approvalRequired

approvalRequired?: boolean;

property branch

branch: string;

property data

data?: string;

property description

description?: string;

Current description that goes with the current status

property descriptions

descriptions?: {
    canceled: string;
    completed: string;
    failed: string;
    inProcess: string;
    planned: string;
    requested: string;
    stopped: string;
    skipped: string;
    waitingForApproval: string;
    waitingForPreApproval: string;
};

property error

error?: string;

property externalKey

externalKey?: string;

property externalUrls

externalUrls?: Array<{
    label?: string;
    url: string;
}>;

property fulfillment

fulfillment: {
    method: string;
    registration: string;
    name: string;
};

property goalSet

goalSet: string;

property goalSetId

goalSetId: string;

property phase

phase?: string;

property preApproval

preApproval?: SdmProvenance;

property preApprovalRequired

preApprovalRequired?: boolean;

property preConditions

preConditions: SdmGoalKey[];

property provenance

provenance: SdmProvenance[];

property push

push: PushFields.Fragment;

property registration

registration: string;

property repo

repo: {
    owner: string;
    name: string;
    providerId: string;
};

property retryFeasible

retryFeasible?: boolean;

property sha

sha: string;

property state

state: SdmGoalState;

property ts

ts: number;

Timestamp

property url

url?: string;

property version

version?: number;

interface SdmGoalSetMessage

interface SdmGoalSetMessage {}

Data persisted in the Atomist Cortex

property branch

branch: string;

property goals

goals: Array<{
    name: string;
    uniqueName: string;
}>;

property goalSet

goalSet: string;

property goalSetId

goalSetId: string;

property provenance

provenance: SdmProvenance;

property repo

repo: {
    name: string;
    owner: string;
    providerId: string;
};

property sha

sha: string;

property state

state: SdmGoalState;

property tags

tags?: GoalSetTag[];

property ts

ts: number;

interface ServiceRegistration

interface ServiceRegistration<T> {}

Register additional services for a goal. This can be used to add additional containers into k8s jobs to use during goal execution.

property name

name: string;

property service

service: (
    goalEvent: SdmGoalEvent,
    repo: RepoContext
) => Promise<
    | {
          type: string;
          spec: T;
      }
    | undefined
>;

interface SideEffect

interface SideEffect {}

property name

name: string;

property pushTest

pushTest?: PushTest;

property registration

registration: string;

interface SigningKey

interface SigningKey<T> extends VerificationKey<T> {}

Private/public key pair to use for SDM goal signing and verification

property passphrase

passphrase?: string;

property privateKey

privateKey: T;

interface SimpleCache

interface SimpleCache<T> {}

Simple interface for a string-keyed cache

property stats

stats: CacheStats;

method evict

evict: (key: string) => void;

method get

get: (key: string) => T;

method put

put: (key: string, value: T) => void;

interface SkillConfiguration

interface SkillConfiguration<C extends Record<string, any> = any> {}

Skills get configured and the named configuration gets passed to the running command or event handler

property name

name: string;

Name of the configuration

property parameters

parameters: C;

interface SkillContext

interface SkillContext<C = any> {}

Skills get additional contextual information when they execute

property configuration

configuration?: SkillConfiguration<C>;

Optional configuration of the skill

interface SlackReviewRoutingParams

interface SlackReviewRoutingParams {}

property deepLink

deepLink: DeepLink;

property pushReactionResponse

pushReactionResponse?: PushImpactResponse;

interface SoftwareDeliveryMachine

interface SoftwareDeliveryMachine<
    O extends SoftwareDeliveryMachineConfiguration = SoftwareDeliveryMachineConfiguration
> extends GoalDrivenMachine<O>,
        ListenerRegistrationManager,
        CommandRegistrationManager,
        EventRegistrationManager,
        IngesterRegistrationManager,
        FunctionalUnit {}

Class instantiated to create a **Software Delivery MachineConfiguration**. Combines commands and delivery event handling using _goals_.
Goals and goal "implementations" can be defined by users.
The most important element of a software delivery machine is setting zero or more _push rules_. This is normally done using an internal DSL

property extensionPacks

readonly extensionPacks: ReadonlyArray<ExtensionPack>;

method addExtensionPacks

addExtensionPacks: (...packs: ExtensionPack[]) => this;

Add capabilities from these extension packs. This is the primary SDM extension mechanism. Extension packs are typically brought in as Node modules, and can contribute goals as well configure SDM behavior.
Parameter packs
{this}

interface SoftwareDeliveryMachineConfiguration

interface SoftwareDeliveryMachineConfiguration<AdditionalConfiguration = {}>
    extends Configuration {}

Configuration that takes SoftwareDeliveryMachineOptions inside the sdm key.

property sdm

sdm: SoftwareDeliveryMachineOptions & AdditionalConfiguration & AnyOptions;

interface SoftwareDeliveryMachineOptions

interface SoftwareDeliveryMachineOptions {}

Infrastructure options common to all SoftwareDeliveryMachines. Can be used to control the behavior of an SDM, and also to facilitate testing.

property adminAddressChannels

adminAddressChannels?: AddressChannels;

Optional AddressChannels for communicating with system administrator Defaults to logging a warning unless this is set.

property credentialsResolver

credentialsResolver?: CredentialsResolver;

Strategy for resolving credentials from a handler invocation

property enrichGoal

enrichGoal?: EnrichGoal;

Callback to enrich goal metadata before it gets persisted and planned

property eventSigning

eventSigning?: EventSigningConfiguration;

Optional set o of keys to sign and verify custom events.

property goalScheduler

goalScheduler?: GoalScheduler | GoalScheduler[];

Optional strategy for launching goals in different infrastructure

property goalSigning

goalSigning?: GoalSigningConfiguration;

Optional set of keys to sign and verify goals that are produced and received by this SDM.

property logFactory

logFactory?: ProgressLogFactory;

Factory for loggers used to log specific activities such as build and deployment.

property parameterPromptFactory

parameterPromptFactory?: ParameterPromptFactory<any>;

Optional strategy to allow prompting for additional parameters

property preferenceStoreFactory

preferenceStoreFactory?: PreferenceStoreFactory;

Optional strategy to create a new PreferenceStore implementation

property projectLoader

projectLoader?: ProjectLoader;

Object used to load projects

property projectPersister

projectPersister?: ProjectPersister;

Strategy for persisting new projects

property repoFinder

repoFinder?: RepoFinder;

Strategy for finding all repos to act on

property repoRefResolver

repoRefResolver?: RepoRefResolver;

Strategy for resolving Git repository references

property tagGoalSet

tagGoalSet?: TagGoalSet;

Callback to add tags to created goal sets

property targets

targets?: Maker<RepoTargets>;

Allow customization of editor targeting at per-SDM level. If set, can still be overridden by individual editor registrations.

interface SpawnLogCommand

interface SpawnLogCommand {}

Interface containing the arguments to spawnAndLog.

property args

args?: string[];

Arguments to command

property command

command: string;

Executable able to be run by cross-spawn.

property options

options?: SpawnLogOptions;

Options to customize how command is run.

interface SpawnLogInvocation

interface SpawnLogInvocation {}

Interface similar to [[SpawnLogCommand]] but making the log property optional since that can typically be obtained other ways when commands are invoked from within goals.

property args

args?: string[];

Arguments to command

property command

command: string;

Executable able to be run by cross-spawn.

property options

options?: Partial<SpawnLogOptions>;

Options to customize how command is run.

interface SpawnLogOptions

interface SpawnLogOptions extends SpawnPromiseOptions {}

Add an error finder to SpawnPromietOptions to allow for poorly-behaved command-line tools that do not properly reflect their status in their return code.

property errorFinder

errorFinder?: ErrorFinder;

If your command can return zero on failure or non-zero on success, you can override the default behavior of determining success or failure using this option. For example, if your command returns zero for certain types of errors, you can scan the log content from the command to determine if an error occurs. If this function finds an error, the error property will be populated with an Error.

property log

log: ProgressLog;

Make SpawnPromiseOptions log mandatory and a ProgressLog.

interface StatefulInvocation

interface StatefulInvocation<S> extends SdmContext {}

Add state to an invocation. Only available in memory.
Parameter S
type of the fact to add.

property facts

facts?: S;

interface StatefulPushListenerInvocation

interface StatefulPushListenerInvocation<S = DefaultFacts>
    extends PushListenerInvocation,
        StatefulInvocation<S> {}

Within evaluation of push rules we can manage state on a push. This interface allows state. This state will not be persisted.

interface StaticPushMapping

interface StaticPushMapping<V> extends PushMapping<V> {}

PushMapping that always returns the same value, guarded by a PushTest. Return undefined if the PushTest doesn't match.

property pushTest

readonly pushTest: PushTest;

property value

readonly value: V;

Value we always return

interface TagListenerInvocation

interface TagListenerInvocation extends RepoListenerInvocation {}

Invocation when a tag has been created on a repo

property tag

tag: Tag;

interface TransformModeSuggestion

interface TransformModeSuggestion {}

Interface that can be implemented by CodeTransform parameters that can suggest the mode to present changes to users.

property desiredBranchName

desiredBranchName: string;

property desiredCommitMessage

desiredCommitMessage?: string;

property desiredPullRequestTitle

desiredPullRequestTitle?: string;

interface TriggeredListenerRegistration

interface TriggeredListenerRegistration {}

property listener

listener: TriggeredListener;

Listener to invoke when the trigger fires

property trigger

trigger: {
    cron?: string;
    interval?: number;
};

Trigger can be a cron expression as string and/or a interval in milliseconds

interface UpdatedIssueListenerInvocation

interface UpdatedIssueListenerInvocation extends IssueListenerInvocation {}

Invocation on an updated issue

property issue

issue: schema.OnIssueAction.Issue;

interface UpdateSdmGoalParams

interface UpdateSdmGoalParams {}

property approved

approved?: boolean;

property data

data?: string;

property description

description: string;

property error

error?: Error;

property externalUrls

externalUrls?: Array<{
    label?: string;
    url: string;
}>;

property phase

phase?: string;

property state

state: SdmGoalState;

property url

url?: string;

interface UserJoiningChannelListenerInvocation

interface UserJoiningChannelListenerInvocation extends ListenerInvocation {}

property joinEvent

joinEvent: schema.OnUserJoiningChannel.UserJoinedChannel;

property repos

repos: RemoteRepoRef[];

Any linked repo refs

interface VerificationKey

interface VerificationKey<T> {}

property algorithm

algorithm?: string;

property name

name: string;

property publicKey

publicKey: T;

interface WaitRules

interface WaitRules {}

Rules for waiting for a predicated goal. Specify timeout in seconds or milliseconds.

property condition

condition: (gi: GoalInvocation) => Promise<boolean>;

property retries

retries?: number;

property timeoutMillis

timeoutMillis?: number;

property timeoutSeconds

timeoutSeconds?: number;

interface WellKnownGoals

interface WellKnownGoals {}

Commonly used goals in an SDM that may be used in creating an ExtensionPack

property autofixGoal

autofixGoal?: Autofix;

Autofix goal to add autofixes to. Autofix functionality won't work otherwise.

property inspectGoal

inspectGoal?: AutoCodeInspection;

Inspect goal to add inspections to. Review functionality won't work otherwise.

property pushImpactGoal

pushImpactGoal?: PushImpact;

pushImpactGoal to add push impact reactions to.

Enums

enum ApplyPolicyState

enum ApplyPolicyState {
    success = 'success',
    no_change = 'no_change',
    failure = 'failure',
}

member failure

failure = 'failure'

member no_change

no_change = 'no_change'

member success

success = 'success'

enum AspectRegistrationState

enum AspectRegistrationState {
    Disabled = 'Disabled',
    Enabled = 'Enabled',
}

member Disabled

Disabled = 'Disabled'

member Enabled

Enabled = 'Enabled'

enum AtmInitialJobState

enum AtmInitialJobState {
    preparing = 'preparing',
    running = 'running',
}

The initial state of an AtmJob

member preparing

preparing = 'preparing'

member running

running = 'running'

enum AtmJobState

enum AtmJobState {
    preparing = 'preparing',
    running = 'running',
    completed = 'completed',
    timedout = 'timedout',
}

The state of an AtmJob

member completed

completed = 'completed'

member preparing

preparing = 'preparing'

member running

running = 'running'

member timedout

timedout = 'timedout'

enum AtmJobTaskState

enum AtmJobTaskState {
    created = 'created',
    running = 'running',
    failed = 'failed',
    success = 'success',
}

The state of a AtmJobTask

member created

created = 'created'

member failed

failed = 'failed'

member running

running = 'running'

member success

success = 'success'

enum AtomistSkillCategoryKey

enum AtomistSkillCategoryKey {
    BUILD = 'BUILD',
    CHAT = 'CHAT',
    CODE_MAINTENANCE = 'CODE_MAINTENANCE',
    CODE_QUALITY = 'CODE_QUALITY',
    CODE_REVIEW = 'CODE_REVIEW',
    DEPENDENCIES = 'DEPENDENCIES',
    DEPLOY = 'DEPLOY',
    DEVEX = 'DEVEX',
    DEVOPS = 'DEVOPS',
    ISSUES = 'ISSUES',
    MONITOR = 'MONITOR',
    NOTIFICATIONS = 'NOTIFICATIONS',
    PROJECT_MANAGEMENT = 'PROJECT_MANAGEMENT',
    REPO_MANAGEMENT = 'REPO_MANAGEMENT',
    SECURITY = 'SECURITY',
}

member BUILD

BUILD = 'BUILD'

member CHAT

CHAT = 'CHAT'

member CODE_MAINTENANCE

CODE_MAINTENANCE = 'CODE_MAINTENANCE'

member CODE_QUALITY

CODE_QUALITY = 'CODE_QUALITY'

member CODE_REVIEW

CODE_REVIEW = 'CODE_REVIEW'

member DEPENDENCIES

DEPENDENCIES = 'DEPENDENCIES'

member DEPLOY

DEPLOY = 'DEPLOY'

member DEVEX

DEVEX = 'DEVEX'

member DEVOPS

DEVOPS = 'DEVOPS'

member ISSUES

ISSUES = 'ISSUES'

member MONITOR

MONITOR = 'MONITOR'

member NOTIFICATIONS

NOTIFICATIONS = 'NOTIFICATIONS'

member PROJECT_MANAGEMENT

PROJECT_MANAGEMENT = 'PROJECT_MANAGEMENT'

member REPO_MANAGEMENT

REPO_MANAGEMENT = 'REPO_MANAGEMENT'

member SECURITY

SECURITY = 'SECURITY'

enum AtomistSkillEventDispatchStyle

enum AtomistSkillEventDispatchStyle {
    single = 'single',
    multiple = 'multiple',
}

member multiple

multiple = 'multiple'

member single

single = 'single'

enum AtomistSkillExecutionLogCategory

enum AtomistSkillExecutionLogCategory {
    developer = 'developer',
    user = 'user',
}

member developer

developer = 'developer'

member user

user = 'user'

enum AtomistSkillExecutionLogSeverity

enum AtomistSkillExecutionLogSeverity {
    error = 'error',
    warn = 'warn',
    info = 'info',
    debug = 'debug',
    trace = 'trace',
}

member debug

debug = 'debug'

member error

error = 'error'

member info

info = 'info'

member trace

trace = 'trace'

member warn

warn = 'warn'

enum AtomistSkillExecutionPlatform

enum AtomistSkillExecutionPlatform {
    gcf = 'gcf',
    docker = 'docker',
}

member docker

docker = 'docker'

member gcf

gcf = 'gcf'

enum AtomistSkillExecutionSortField

enum AtomistSkillExecutionSortField {
    start_time = 'start_time',
    end_time = 'end_time',
}

member end_time

end_time = 'end_time'

member start_time

start_time = 'start_time'

enum AtomistSkillExecutionSortOrder

enum AtomistSkillExecutionSortOrder {
    asc = 'asc',
    desc = 'desc',
}

member asc

asc = 'asc'

member desc

desc = 'desc'

enum AtomistSkillExecutionState

enum AtomistSkillExecutionState {
    queued = 'queued',
    running = 'running',
    completed = 'completed',
    success = 'success',
    failed = 'failed',
    timeout = 'timeout',
    crash = 'crash',
    unknown = 'unknown',
}

member completed

completed = 'completed'

member crash

crash = 'crash'

member failed

failed = 'failed'

member queued

queued = 'queued'

member running

running = 'running'

member success

success = 'success'

member timeout

timeout = 'timeout'

member unknown

unknown = 'unknown'

enum AtomistSkillExecutionTriggerEventType

enum AtomistSkillExecutionTriggerEventType {
    command = 'command',
    subscription = 'subscription',
    webhook = 'webhook',
}

member command

command = 'command'

member subscription

subscription = 'subscription'

member webhook

webhook = 'webhook'

enum AtomistSkillExecutionVisibility

enum AtomistSkillExecutionVisibility {
    visible = 'visible',
    hidden = 'hidden',
}

member hidden

hidden = 'hidden'

member visible

visible = 'visible'

enum AtomistSkillMaturityLevel

enum AtomistSkillMaturityLevel {
    stable = 'stable',
    testing = 'testing',
    unstable = 'unstable',
}

member stable

stable = 'stable'

Release quality

member testing

testing = 'testing'

Candidate for next release, but might still have issues

member unstable

unstable = 'unstable'

CI build - expect bugs

enum AtomistSkillParameterVisiblity

enum AtomistSkillParameterVisiblity {
    hidden = 'hidden',
    advanced = 'advanced',
    normal = 'normal',
}

member advanced

advanced = 'advanced'

member hidden

hidden = 'hidden'

member normal

normal = 'normal'

enum AtomistSkillRequiredCapabilityScope

enum AtomistSkillRequiredCapabilityScope {
    ingestion = 'ingestion',
    configuration = 'configuration',
}

member configuration

configuration = 'configuration'

member ingestion

ingestion = 'ingestion'

enum AtomistSkillRuntime

enum AtomistSkillRuntime {
    nodejs10 = 'nodejs10',
    nodejs12 = 'nodejs12',
    python37 = 'python37',
    python38 = 'python38',
    go113 = 'go113',
    java11 = 'java11',
}

member go113

go113 = 'go113'

member java11

java11 = 'java11'

member nodejs10

nodejs10 = 'nodejs10'

member nodejs12

nodejs12 = 'nodejs12'

member python37

python37 = 'python37'

member python38

python38 = 'python38'

enum AtomistSkillStatusCode

enum AtomistSkillStatusCode {
    registered = 'registered',
    scheduled = 'scheduled',
    deploying = 'deploying',
    running = 'running',
    error = 'error',
    undeployed = 'undeployed',
}

member deploying

deploying = 'deploying'

member error

error = 'error'

member registered

registered = 'registered'

member running

running = 'running'

member scheduled

scheduled = 'scheduled'

member undeployed

undeployed = 'undeployed'

enum AtomistSkillStringParameterLineStyle

enum AtomistSkillStringParameterLineStyle {
    single = 'single',
    multiple = 'multiple',
}

member multiple

multiple = 'multiple'

member single

single = 'single'

enum AtomistSkillTechnology

enum AtomistSkillTechnology {
    JAVA = 'JAVA',
    MAVEN = 'MAVEN',
    DOCKER = 'DOCKER',
    JAVASCRIPT = 'JAVASCRIPT',
    NPM = 'NPM',
    LEIN = 'LEIN',
    CLOJURE = 'CLOJURE',
    KUBERNETES = 'KUBERNETES',
}

member CLOJURE

CLOJURE = 'CLOJURE'

member DOCKER

DOCKER = 'DOCKER'

member JAVA

JAVA = 'JAVA'

member JAVASCRIPT

JAVASCRIPT = 'JAVASCRIPT'

member KUBERNETES

KUBERNETES = 'KUBERNETES'

member LEIN

LEIN = 'LEIN'

member MAVEN

MAVEN = 'MAVEN'

member NPM

NPM = 'NPM'

enum AtomistSkillUpgradePolicy

enum AtomistSkillUpgradePolicy {
    stable = 'stable',
    unstable = 'unstable',
    testing = 'testing',
    manual = 'manual',
}

member manual

manual = 'manual'

member stable

stable = 'stable'

member testing

testing = 'testing'

member unstable

unstable = 'unstable'

enum BinaryRepositoryType

enum BinaryRepositoryType {
    maven2 = 'maven2',
    npm = 'npm',
}

member maven2

maven2 = 'maven2'

member npm

npm = 'npm'

enum BucketUnit

enum BucketUnit {
    YEAR = 'YEAR',
    MONTH = 'MONTH',
    DAY = 'DAY',
    HOUR = 'HOUR',
    MINUTE = 'MINUTE',
    SECOND = 'SECOND',
}

member DAY

DAY = 'DAY'

Group events by day.

member HOUR

HOUR = 'HOUR'

Group events by hour.

member MINUTE

MINUTE = 'MINUTE'

Group events by minute.

member MONTH

MONTH = 'MONTH'

Group events by month.

member SECOND

SECOND = 'SECOND'

Group events by second.

member YEAR

YEAR = 'YEAR'

Group events by year.

enum BuildStatus

enum BuildStatus {
    passed = 'passed',
    broken = 'broken',
    failed = 'failed',
    started = 'started',
    canceled = 'canceled',
    pending = 'pending',
    error = 'error',
    queued = 'queued',
}

Enum for BuildStatus

member broken

broken = 'broken'

member canceled

canceled = 'canceled'

member error

error = 'error'

member failed

failed = 'failed'

member passed

passed = 'passed'

member pending

pending = 'pending'

member queued

queued = 'queued'

member started

started = 'started'

enum BuildTrigger

enum BuildTrigger {
    pull_request = 'pull_request',
    push = 'push',
    tag = 'tag',
    cron = 'cron',
}

Enum for BuildTrigger

member cron

cron = 'cron'

Value for cron

member pull_request

pull_request = 'pull_request'

Value for pull_request

member push

push = 'push'

Value for push

member tag

tag = 'tag'

Value for tag

enum ChatTeamState

enum ChatTeamState {
    initializing = 'initializing',
    initialized = 'initialized',
}

member initialized

initialized = 'initialized'

member initializing

initializing = 'initializing'

enum CheckRunAction

enum CheckRunAction {
    created = 'created',
    completed = 'completed',
    rerequested = 'rerequested',
    requested_action = 'requested_action',
}

member completed

completed = 'completed'

member created

created = 'created'

member requested_action

requested_action = 'requested_action'

member rerequested

rerequested = 'rerequested'

enum CheckRunConclusion

enum CheckRunConclusion {
    success = 'success',
    failure = 'failure',
    neutral = 'neutral',
    cancelled = 'cancelled',
    skipped = 'skipped',
    timed_out = 'timed_out',
    action_required = 'action_required',
    stale = 'stale',
}

member action_required

action_required = 'action_required'

member cancelled

cancelled = 'cancelled'

member failure

failure = 'failure'

member neutral

neutral = 'neutral'

member skipped

skipped = 'skipped'

member stale

stale = 'stale'

member success

success = 'success'

member timed_out

timed_out = 'timed_out'

enum CheckRunStatus

enum CheckRunStatus {
    queued = 'queued',
    in_progress = 'in_progress',
    completed = 'completed',
}

member completed

completed = 'completed'

member in_progress

in_progress = 'in_progress'

member queued

queued = 'queued'

enum CheckSuiteAction

enum CheckSuiteAction {
    completed = 'completed',
    requested = 'requested',
    rerequested = 'rerequested',
}

member completed

completed = 'completed'

member requested

requested = 'requested'

member rerequested

rerequested = 'rerequested'

enum CheckSuiteConclusion

enum CheckSuiteConclusion {
    success = 'success',
    failure = 'failure',
    neutral = 'neutral',
    cancelled = 'cancelled',
    timed_out = 'timed_out',
    action_required = 'action_required',
    stale = 'stale',
}

member action_required

action_required = 'action_required'

member cancelled

cancelled = 'cancelled'

member failure

failure = 'failure'

member neutral

neutral = 'neutral'

member stale

stale = 'stale'

member success

success = 'success'

member timed_out

timed_out = 'timed_out'

enum CheckSuiteStatus

enum CheckSuiteStatus {
    requested = 'requested',
    in_progress = 'in_progress',
    completed = 'completed',
    queued = 'queued',
}

member completed

completed = 'completed'

member in_progress

in_progress = 'in_progress'

member queued

queued = 'queued'

member requested

requested = 'requested'

enum CommentCommentType

enum CommentCommentType {
    review = 'review',
    pullRequest = 'pullRequest',
    issue = 'issue',
}

Enum for CommentCommentType

member issue

issue = 'issue'

Value for issue

member pullRequest

pullRequest = 'pullRequest'

Value for pullRequest

member review

review = 'review'

Value for review

enum CommitIssueRelationshipType

enum CommitIssueRelationshipType {
    references = 'references',
    fixes = 'fixes',
}

member fixes

fixes = 'fixes'

member references

references = 'references'

enum ConfigurationValueType

enum ConfigurationValueType {
    Number = 0,
    String = 1,
    Boolean = 2,
}

Describe the type of configuration value

member Boolean

Boolean = 2

member Number

Number = 0

member String

String = 1

enum CredentialType

enum CredentialType {
    OAuthToken = 'OAuthToken',
    Password = 'Password',
}

member OAuthToken

OAuthToken = 'OAuthToken'

member Password

Password = 'Password'

enum DeclarationType

enum DeclarationType {
    Mapped = 'mapped',
    Secret = 'secret',
}

member Mapped

Mapped = 'mapped'

member Secret

Secret = 'secret'

enum DockerRegistryType

enum DockerRegistryType {
    JFrog = 'JFrog',
    DockerHub = 'DockerHub',
}

Deprecated

member DockerHub

DockerHub = 'DockerHub'

member JFrog

JFrog = 'JFrog'

enum EventType

enum EventType {
    CHAT = 'CHAT',
    CUSTOM = 'CUSTOM',
    SCM = 'SCM',
}

member CHAT

CHAT = 'CHAT'

Chat events which have been received.

member CUSTOM

CUSTOM = 'CUSTOM'

Custom events which have been received.

member SCM

SCM = 'SCM'

Events which have been received from an SCM source.

enum ExpectedPredicateMappingCost

enum ExpectedPredicateMappingCost {
    cheap = 'cheap',
    expensive = 'expensive',
    unknown = 'unknown',
}

Classification of expected PredicateMapping cost

member cheap

cheap = 'cheap'

member expensive

expensive = 'expensive'

member unknown

unknown = 'unknown'

enum GoalApprovalRequestVote

enum GoalApprovalRequestVote {
    Abstain = 'abstain',
    Granted = 'granted',
    Denied = 'denied',
}

Represents a vote on a approval request

member Abstain

Abstain = 'abstain'

Voter decided to abstain from voting

member Denied

Denied = 'denied'

Voter decided to deny the approval request

member Granted

Granted = 'granted'

Voter decided to grant the approval request

enum GoalProjectListenerEvent

enum GoalProjectListenerEvent {
    before = 'before',
    after = 'after',
}

member after

after = 'after'

member before

before = 'before'

enum GoalSettingCompositionStyle

enum GoalSettingCompositionStyle {
    FirstMatch = 'take the first one',
    AllMatches = 'take all the ones that match',
}

member AllMatches

AllMatches = 'take all the ones that match'

member FirstMatch

FirstMatch = 'take the first one'

enum GoalSigningScope

enum GoalSigningScope {
    Fulfillment = 'fulfillment',
    All = 'all',
}

Defines the scope of which goes get signed and validated

member All

All = 'all'

Verify each incoming goal into any of the SDM event handlers

member Fulfillment

Fulfillment = 'fulfillment'

Only verify incoming goals for fulfillment

enum IssueState

enum IssueState {
    open = 'open',
    closed = 'closed',
    deleted = 'deleted',
}

member closed

closed = 'closed'

member deleted

deleted = 'deleted'

member open

open = 'open'

enum JobStatus

enum JobStatus {
    created = 'created',
    pending = 'pending',
    running = 'running',
    failed = 'failed',
    success = 'success',
    canceled = 'canceled',
    skipped = 'skipped',
    manual = 'manual',
}

Enum for JobStatus

member canceled

canceled = 'canceled'

member created

created = 'created'

member failed

failed = 'failed'

member manual

manual = 'manual'

member pending

pending = 'pending'

member running

running = 'running'

member skipped

skipped = 'skipped'

member success

success = 'success'

enum JobTaskType

enum JobTaskType {
    Command = 'command',
}

member Command

Command = 'command'

enum LifecycleAttachmentType

enum LifecycleAttachmentType {
    push = 'push',
}

member push

push = 'push'

enum ManageSubscriptionPolicyAction

enum ManageSubscriptionPolicyAction {
    ignore = 'ignore',
    unignore = 'unignore',
    subscribe = 'subscribe',
    unsubscribe = 'unsubscribe',
}

member ignore

ignore = 'ignore'

subscribe = 'subscribe'

member unignore

unignore = 'unignore'

member unsubscribe

unsubscribe = 'unsubscribe'

enum ManageTargetPolicyAction

enum ManageTargetPolicyAction {
    unset = 'unset',
    set = 'set',
}

member set

set = 'set'

member unset

unset = 'unset'

enum MappingCompositionStyle

enum MappingCompositionStyle {
    ApplyFunctionToOutput = 'like Array.map',
}

member ApplyFunctionToOutput

ApplyFunctionToOutput = 'like Array.map'

enum MergeStatus

enum MergeStatus {
    can_be_merged = 'can_be_merged',
    unchecked = 'unchecked',
    cannot_be_merged = 'cannot_be_merged',
}

Enum for MergeStatus

member can_be_merged

can_be_merged = 'can_be_merged'

Value for can_be_merged

member cannot_be_merged

cannot_be_merged = 'cannot_be_merged'

Value for cannot_be_merged

member unchecked

unchecked = 'unchecked'

Value for unchecked

enum MockGoalSize

enum MockGoalSize {
    Small = 5,
    Medium = 20,
    Large = 60,
    ExtraLarge = 90,
}

Enum to describe goal sizes when creating mock goal executors

member ExtraLarge

ExtraLarge = 90

member Large

Large = 60

member Medium

Medium = 20

member Small

Small = 5

enum OrgInitializationState

enum OrgInitializationState {
    initializing = 'initializing',
    initialized = 'initialized',
}

member initialized

initialized = 'initialized'

member initializing

initializing = 'initializing'

enum OwnerType

enum OwnerType {
    user = 'user',
    organization = 'organization',
}

member organization

organization = 'organization'

member user

user = 'user'

enum ParameterStyle

enum ParameterStyle {
    Dialog = 'dialog',
    Threaded = 'threaded',
    Unthreaded = 'unthreaded',
    DialogAction = 'dialog_action',
}

Different strategies to ask for parameters in chat or web

member Dialog

Dialog = 'dialog'

Parameter questions will be prompted in a dialog

member DialogAction

DialogAction = 'dialog_action'

Parameter questions will be prompted in a dialog if the command is triggered from a button or menu

member Threaded

Threaded = 'threaded'

Parameter questions will be prompted in a thread

member Unthreaded

Unthreaded = 'unthreaded'

Parameter questions will be prompted in the channel where the command is being run

enum PipelineProvider

enum PipelineProvider {
    gitlab_ci = 'gitlab_ci',
}

Enum for the PipelineProviders

member gitlab_ci

gitlab_ci = 'gitlab_ci'

Gitlab CI Pipeline

enum PipelineStatus

enum PipelineStatus {
    running = 'running',
    pending = 'pending',
    success = 'success',
    failed = 'failed',
    canceled = 'canceled',
    skipped = 'skipped',
    manual = 'manual',
}

Enum for PipelineStatus

member canceled

canceled = 'canceled'

member failed

failed = 'failed'

member manual

manual = 'manual'

member pending

pending = 'pending'

member running

running = 'running'

member skipped

skipped = 'skipped'

member success

success = 'success'

enum PolicyCompliaceState

enum PolicyCompliaceState {
    created = 'created',
    in_review = 'in_review',
    reviewed = 'reviewed',
}

member created

created = 'created'

member in_review

in_review = 'in_review'

member reviewed

reviewed = 'reviewed'

enum PredicateMappingCompositionStyle

enum PredicateMappingCompositionStyle {
    And = 'and',
    Or = 'or',
    Not = 'not',
}

Style of logical composition

member And

And = 'and'

member Not

Not = 'not'

member Or

Or = 'or'

enum PreferenceScope

enum PreferenceScope {
    Sdm = 'sdm',
    Workspace = 'workspace',
}

Scope of a preference

member Sdm

Sdm = 'sdm'

member Workspace

Workspace = 'workspace'

enum ProviderType

enum ProviderType {
    bitbucket_cloud = 'bitbucket_cloud',
    github_com = 'github_com',
    ghe = 'ghe',
    bitbucket = 'bitbucket',
    gitlab = 'gitlab',
}

Enum for ProviderType

member bitbucket

bitbucket = 'bitbucket'

member bitbucket_cloud

bitbucket_cloud = 'bitbucket_cloud'

member ghe

ghe = 'ghe'

member github_com

github_com = 'github_com'

member gitlab

gitlab = 'gitlab'

enum PullRequestAction

enum PullRequestAction {
    assigned = 'assigned',
    created = 'created',
    unassigned = 'unassigned',
    review_requested = 'review_requested',
    review_request_removed = 'review_request_removed',
    labeled = 'labeled',
    unlabeled = 'unlabeled',
    opened = 'opened',
    edited = 'edited',
    closed = 'closed',
    reopened = 'reopened',
    synchronize = 'synchronize',
    submitted = 'submitted',
    ready_for_review = 'ready_for_review',
}

member assigned

assigned = 'assigned'

member closed

closed = 'closed'

member created

created = 'created'

member edited

edited = 'edited'

member labeled

labeled = 'labeled'

member opened

opened = 'opened'

member ready_for_review

ready_for_review = 'ready_for_review'

member reopened

reopened = 'reopened'

member review_request_removed

review_request_removed = 'review_request_removed'

member review_requested

review_requested = 'review_requested'

member submitted

submitted = 'submitted'

member synchronize

synchronize = 'synchronize'

member unassigned

unassigned = 'unassigned'

member unlabeled

unlabeled = 'unlabeled'

enum PushImpactResponse

enum PushImpactResponse {
    proceed = 'proceed',
    failGoals = 'fail',
    requireApprovalToProceed = 'requireApproval',
}

A code action response that affects delivery: failing the current goal or requiring approval, causing dependent goals to fail or wait.

member failGoals

failGoals = 'fail'

Fail execution of the present goalset. Any dependent goals will stop. Will not stop execution of non-dependent goals.

member proceed

proceed = 'proceed'

Everything's good. Keep going.

member requireApprovalToProceed

requireApprovalToProceed = 'requireApproval'

Require approval to proceed to dependent goals in the present goalset.

enum ReleaseAction

enum ReleaseAction {
    published = 'published',
    unpublished = 'unpublished',
    created = 'created',
    edited = 'edited',
    deleted = 'deleted',
    prereleased = 'prereleased',
    released = 'released',
}

member created

created = 'created'

member deleted

deleted = 'deleted'

member edited

edited = 'edited'

member prereleased

prereleased = 'prereleased'

member published

published = 'published'

member released

released = 'released'

member unpublished

unpublished = 'unpublished'

enum ResourceProviderStateName

enum ResourceProviderStateName {
    converged = 'converged',
    unconverged = 'unconverged',
    misconfigured = 'misconfigured',
    unauthorized = 'unauthorized',
}

member converged

converged = 'converged'

member misconfigured

misconfigured = 'misconfigured'

member unauthorized

unauthorized = 'unauthorized'

member unconverged

unconverged = 'unconverged'

enum ResourceUserType

enum ResourceUserType {
    SCMId = 'SCMId',
    GenericResourceUser = 'GenericResourceUser',
    SystemAccount = 'SystemAccount',
    GitHubAppResourceUser = 'GitHubAppResourceUser',
}

member GenericResourceUser

GenericResourceUser = 'GenericResourceUser'

member GitHubAppResourceUser

GitHubAppResourceUser = 'GitHubAppResourceUser'

member SCMId

SCMId = 'SCMId'

member SystemAccount

SystemAccount = 'SystemAccount'

enum ReviewState

enum ReviewState {
    requested = 'requested',
    pending = 'pending',
    approved = 'approved',
    commented = 'commented',
    unapproved = 'unapproved',
    changes_requested = 'changes_requested',
}

Enum for ReviewState

member approved

approved = 'approved'

Value for approved

member changes_requested

changes_requested = 'changes_requested'

Value for changes_requested

member commented

commented = 'commented'

Value for commented

member pending

pending = 'pending'

Value for pending

member requested

requested = 'requested'

Value for requested

member unapproved

unapproved = 'unapproved'

Value for unapproved

enum ScmProviderStateName

enum ScmProviderStateName {
    converged = 'converged',
    unconverged = 'unconverged',
    misconfigured = 'misconfigured',
    unauthorized = 'unauthorized',
}

member converged

converged = 'converged'

member misconfigured

misconfigured = 'misconfigured'

member unauthorized

unauthorized = 'unauthorized'

member unconverged

unconverged = 'unconverged'

enum SdmDeployState

enum SdmDeployState {
    requested = 'requested',
    disabled = 'disabled',
}

member disabled

disabled = 'disabled'

member requested

requested = 'requested'

enum SdmGoalDisplayFormat

enum SdmGoalDisplayFormat {
    compact = 'compact',
    full = 'full',
}

member compact

compact = 'compact'

member full

full = 'full'

enum SdmGoalDisplayState

enum SdmGoalDisplayState {
    show_current = 'show_current',
    show_all = 'show_all',
}

member show_all

show_all = 'show_all'

member show_current

show_current = 'show_current'

enum SdmGoalState

enum SdmGoalState {
    success = 'success',
    pre_approved = 'pre_approved',
    requested = 'requested',
    waiting_for_pre_approval = 'waiting_for_pre_approval',
    approved = 'approved',
    waiting_for_approval = 'waiting_for_approval',
    failure = 'failure',
    stopped = 'stopped',
    planned = 'planned',
    in_process = 'in_process',
    skipped = 'skipped',
    canceled = 'canceled',
}

member approved

approved = 'approved'

member canceled

canceled = 'canceled'

member failure

failure = 'failure'

member in_process

in_process = 'in_process'

member planned

planned = 'planned'

member pre_approved

pre_approved = 'pre_approved'

member requested

requested = 'requested'

member skipped

skipped = 'skipped'

member stopped

stopped = 'stopped'

member success

success = 'success'

member waiting_for_approval

waiting_for_approval = 'waiting_for_approval'

member waiting_for_pre_approval

waiting_for_pre_approval = 'waiting_for_pre_approval'

enum StatusState

enum StatusState {
    pending = 'pending',
    success = 'success',
    error = 'error',
    failure = 'failure',
}

Enum for StatusState

member error

error = 'error'

Value for error

member failure

failure = 'failure'

Value for failure

member pending

pending = 'pending'

Value for pending

member success

success = 'success'

Value for success

enum TimeUnit

enum TimeUnit {
    seconds = 'seconds',
    minutes = 'minutes',
    hours = 'hours',
}

member hours

hours = 'hours'

member minutes

minutes = 'minutes'

member seconds

seconds = 'seconds'

enum WebhookAuthType

enum WebhookAuthType {
    hmac_sha1 = 'hmac_sha1',
    none = 'none',
}

member hmac_sha1

hmac_sha1 = 'hmac_sha1'

member none

none = 'none'

enum WebhookState

enum WebhookState {
    enabled = 'enabled',
    disabled = 'disabled',
}

member disabled

disabled = 'disabled'

member enabled

enabled = 'enabled'

Type Aliases

type AddJobTasksMutation

type AddJobTasksMutation = {
    __typename?: 'Mutation';
} & {
    addAtmJobTasks?: Maybe<
        {
            __typename?: 'AtmJob';
        } & Pick<AtmJob, 'id'>
    >;
};

type AddJobTasksMutationVariables

type AddJobTasksMutationVariables = {
    id: Scalars['String'];
    tasks: Array<AtmJobTaskInput>;
};

type AddressChannels

type AddressChannels = (
    msg: string | SlackMessage | SlackFileMessage,
    opts?: MessageOptions
) => Promise<void>;

Allows us to address channels for a particular repo or any GraphQL type with channels

type Application

type Application = {
    __typename?: 'Application';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** id of  Application */
    id?: Maybe<Scalars['ID']>;
    /** state of  Application */
    state?: Maybe<Scalars['String']>;
    /** host of  Application */
    host?: Maybe<Scalars['String']>;
    /** timestamp of  Application */
    timestamp?: Maybe<Scalars['String']>;
    /** domain of  Application */
    domain?: Maybe<Scalars['String']>;
    /** data of  Application */
    data?: Maybe<Scalars['String']>;
    /** Application commits Commit */
    commits?: Maybe<Array<Maybe<Commit>>>;
};

Application-Node

type ApplicationCommitsArgs

type ApplicationCommitsArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_CommitOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    timestamp?: Maybe<Scalars['String']>;
};

Application-Node

type ApplyPolicyLog

type ApplyPolicyLog = {
    __typename?: 'ApplyPolicyLog';
    _prId?: Maybe<Scalars['ID']>;
    _sha?: Maybe<Scalars['String']>;
    branch?: Maybe<Scalars['String']>;
    commit?: Maybe<Commit>;
    message?: Maybe<Scalars['String']>;
    pullRequest?: Maybe<PullRequest>;
    state?: Maybe<ApplyPolicyState>;
    targetSha?: Maybe<Scalars['String']>;
};

type ArtifactoryMavenRepositoryInput

type ArtifactoryMavenRepositoryInput = {
    url?: Maybe<Scalars['String']>;
    name: Scalars['String'];
};

type ArtifactoryMavenRepositoryProvider

type ArtifactoryMavenRepositoryProvider = ResourceProvider &
    MavenRepositoryProvider & {
        __typename?: 'ArtifactoryMavenRepositoryProvider';
        url: Scalars['String'];
        _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
        _id: Scalars['Int'];
        id: Scalars['ID'];
        name: Scalars['String'];
        team: Team;
        authProviderId?: Maybe<Scalars['String']>;
        state?: Maybe<ResourceProviderState>;
        credential?: Maybe<Credential>;
        webhooks?: Maybe<Array<Maybe<Webhook>>>;
        createdAt: Scalars['String'];
        updatedAt: Scalars['String'];
        createdBy?: Maybe<Person>;
        updatedBy?: Maybe<Person>;
        metadata?: Maybe<ResourceProviderMetadata>;
        timestamp: Scalars['String'];
    };

type ArtifactoryMavenRepositoryProviderWebhooksArgs

type ArtifactoryMavenRepositoryProviderWebhooksArgs = {
    id?: Maybe<Scalars['ID']>;
};

type AspectRegistration

type AspectRegistration = {
    __typename?: 'AspectRegistration';
    category?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    endpoint?: Maybe<Scalars['String']>;
    manageable?: Maybe<Scalars['Boolean']>;
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    shortName?: Maybe<Scalars['String']>;
    state?: Maybe<AspectRegistrationState>;
    unit?: Maybe<Scalars['String']>;
    url?: Maybe<Scalars['String']>;
    uuid?: Maybe<Scalars['String']>;
    /** The ID of this AspectRegistration */
    id?: Maybe<Scalars['ID']>;
};

type AtmJob

type AtmJob = {
    __typename?: 'AtmJob';
    /** An ISO8601 timestamp set by the API when the AtmJob was considered complete (when all tasks were complete) */
    completedAt?: Maybe<Scalars['String']>;
    /** The number of AtmJobTasks on this AtmJob that are in a completed state */
    completedCount: Scalars['Int'];
    /** An ISO8601 timestamp generated by the API when the AtmJob is created */
    createdAt: Scalars['String'];
    /** Used to store additional information about this AtmJob */
    data?: Maybe<Scalars['String']>;
    /** A description for this AtmJob */
    description?: Maybe<Scalars['String']>;
    /** The ID of this AtmJob. Generated by the API. */
    id: Scalars['ID'];
    /** The number of AtmJobTasks that make up this job */
    jobCount: Scalars['Int'];
    /** A list of AtmJobTasks that make up this job */
    jobTasks: Array<AtmJobTask>;
    /** The maximum number of running (in-flight) tasks. By default, all tasks will be in-flight from the time the job is created. */
    maxRunningTasks?: Maybe<Scalars['Int']>;
    /** A name for this AtmJob */
    name: Scalars['String'];
    /** The owner of this job. Clients may use this in a subscription to avoid all clients subscribing to all tasks in a team. */
    owner?: Maybe<Scalars['String']>;
    /** The AtmJobState of this AtmJob */
    state: AtmJobState;
    /** The number of AtmJobTasks that make up this job */
    taskCount: Scalars['Int'];
    /** An ISO8601 timestamp set by the API when the AtmJob is updated */
    updatedAt: Scalars['String'];
    team: Team;
};

A AtmJob, made up of many AtmJobTasks

type AtmJobInput

type AtmJobInput = {
    /** Used to store additional information about this AtmJob */
    data?: Maybe<Scalars['String']>;
    /** A description for this job. */
    description?: Maybe<Scalars['String']>;
    /** The initial state for the job. The default is running. Another option is preparing. */
    initialState?: Maybe<AtmInitialJobState>;
    /** The tasks for the job */
    jobTasks: Array<AtmJobTaskInput>;
    /** The maximum number of running (in-flight) tasks. By default, all tasks will be in-flight from the time the job is created. */
    maxRunningTasks?: Maybe<Scalars['Int']>;
    /** Sets the name for this job */
    name: Scalars['String'];
    /** The owner of this job. Clients may use this in a subscription to avoid all clients subscribing to all tasks in a team. */
    owner?: Maybe<Scalars['String']>;
};

The input object for the creation of a AtmJob

type AtmJobTask

type AtmJobTask = {
    __typename?: 'AtmJobTask';
    /** An ISO8601 timestamp set by the API when the AtmJobTask was considered complete */
    completedAt?: Maybe<Scalars['String']>;
    /** An ISO8601 timestamp generated by the API when the AtmJobTask is created */
    createdAt: Scalars['String'];
    /** Used to store additional information about this AtmJobTask */
    data?: Maybe<Scalars['String']>;
    /** The ID of this AtmJobTask. Generated by the API. */
    id: Scalars['ID'];
    /** Is true if the task is in a completed state */
    isCompleted: Scalars['Boolean'];
    /** The owning job */
    job: AtmJob;
    /** Used to store additional information about the state of this AtmJobTask */
    message?: Maybe<Scalars['String']>;
    /** A name for this AtmJobTask */
    name: Scalars['String'];
    /** The AtmJobTaskState of this AtmJobTask */
    state: AtmJobTaskState;
    /** An ISO8601 timestamp set by the API when the AtmJobTask is updated */
    updatedAt: Scalars['String'];
};

A Task that makes up part of a AtmJob

type AtmJobTaskInput

type AtmJobTaskInput = {
    /** Sets additional information about this AtmJobTask */
    data?: Maybe<Scalars['String']>;
    /** Sets the name for this AtmJobTask */
    name: Scalars['String'];
};

Input object for creation of AtmJobTask

type AtmJobTaskStateInput

type AtmJobTaskStateInput = {
    /** Sets additional information about the state of this AtmJobTask */
    message?: Maybe<Scalars['String']>;
    /** Sets the AtmJobTaskState of this AtmJobState */
    state: AtmJobTaskState;
};

Input object for setting the state of a AtmJobTask

type AtmTaskRequest

type AtmTaskRequest = {
    /** The id of the job */
    jobId: Scalars['String'];
    /** The maxiumum number of tasks to get. Default is 1. */
    maxTaskCount?: Maybe<Scalars['Int']>;
    /** After this amount of time the task will time out and be available for other workers to get this work */
    taskTimeout: Scalars['Int'];
    /** The units (seconds, minutes, hours) to use for the taskTimeout */
    taskTimeoutUnit: TimeUnit;
    /** Specify a name for the worker that is requesting this work */
    worker: Scalars['String'];
};

The input object for proposing an offer of work

type AtomistChatCommand

type AtomistChatCommand = {
    __typename?: 'AtomistChatCommand';
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    pattern: Scalars['String'];
};

type AtomistChatCommandInput

type AtomistChatCommandInput = {
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    pattern: Scalars['String'];
};

type AtomistDockerSkillArtifactInput

type AtomistDockerSkillArtifactInput = {
    args?: Maybe<Array<Scalars['String']>>;
    command?: Maybe<Array<Scalars['String']>>;
    env?: Maybe<Array<AtomistSkillEnvVariableInput>>;
    image: Scalars['String'];
    name: Scalars['ID'];
    resources?: Maybe<AtomistSkillDockerResourcesInput>;
    workingDir?: Maybe<Scalars['String']>;
};

type AtomistDockerSkillResourcesLimit

type AtomistDockerSkillResourcesLimit = {
    __typename?: 'AtomistDockerSkillResourcesLimit';
    /** kubenetes like cpu units */
    cpu?: Maybe<Scalars['Float']>;
    /** memory in megabytes */
    memory?: Maybe<Scalars['Int']>;
};

type AtomistDockerSkillResourcesRequest

type AtomistDockerSkillResourcesRequest = {
    __typename?: 'AtomistDockerSkillResourcesRequest';
    /** kubenetes like cpu units */
    cpu?: Maybe<Scalars['Float']>;
    /** memory in megabytes */
    memory?: Maybe<Scalars['Int']>;
};

type AtomistGcfSkillArtifactInput

type AtomistGcfSkillArtifactInput = {
    entryPoint: Scalars['String'];
    memory?: Maybe<Scalars['Int']>;
    name: Scalars['ID'];
    runtime: AtomistSkillRuntime;
    timeout?: Maybe<Scalars['Int']>;
    url: Scalars['String'];
};

type AtomistKeyValuePair

type AtomistKeyValuePair = {
    __typename?: 'AtomistKeyValuePair';
    name: Scalars['String'];
    value: Scalars['String'];
};

type AtomistLog

type AtomistLog = {
    __typename?: 'AtomistLog';
    category?: Maybe<Scalars['String']>;
    correlation_context?: Maybe<AtomistLogCorrelationContext>;
    id: Scalars['ID'];
    level?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    team_id?: Maybe<Scalars['String']>;
    timestamp: Scalars['String'];
};

type AtomistLogAutomation

type AtomistLogAutomation = {
    __typename?: 'AtomistLogAutomation';
    name?: Maybe<Scalars['String']>;
    version?: Maybe<Scalars['String']>;
};

type AtomistLogCorrelationContext

type AtomistLogCorrelationContext = {
    __typename?: 'AtomistLogCorrelationContext';
    automation?: Maybe<AtomistLogAutomation>;
    correlation_id?: Maybe<Scalars['String']>;
};

type AtomistLogCorrelationContextAutomationArgs

type AtomistLogCorrelationContextAutomationArgs = {
    name?: Maybe<Scalars['String']>;
    version?: Maybe<Scalars['String']>;
};

type AtomistPagedConfiguredSkills

type AtomistPagedConfiguredSkills = {
    __typename?: 'AtomistPagedConfiguredSkills';
    skills: Array<ConfiguredAtomistSkill>;
};

type AtomistPagedRegisteredSkills

type AtomistPagedRegisteredSkills = {
    __typename?: 'AtomistPagedRegisteredSkills';
    skills: Array<RegisteredAtomistSkill>;
};

type AtomistRegistration

type AtomistRegistration = {
    __typename?: 'AtomistRegistration';
    name: Scalars['String'];
};

type AtomistSkill

type AtomistSkill = {
    artifacts: Array<AtomistSkillArtifact>;
    author: Scalars['String'];
    capabilities: AtomistSkillCapabilitiesSpec;
    categories: Array<AtomistSkillCategory>;
    commands: Array<AtomistChatCommand>;
    createdAt: Scalars['String'];
    datalogSubscriptions?: Maybe<Array<AtomistSkillDatalogSubscription>>;
    description: Scalars['String'];
    dispatchStyle: AtomistSkillEventDispatchStyle;
    displayName?: Maybe<Scalars['String']>;
    homepageUrl: Scalars['String'];
    iconUrl: Scalars['String'];
    inCatalog: Scalars['Boolean'];
    ingesters: Array<Scalars['String']>;
    integration: Scalars['Boolean'];
    license: Scalars['String'];
    longDescription: Scalars['String'];
    maturities: Array<AtomistSkillMaturityLevel>;
    maxConfigurations: Scalars['Int'];
    name: Scalars['String'];
    namespace: Scalars['String'];
    owner: Scalars['Boolean'];
    parameters: Array<AtomistSkillParameterSpec>;
    platform: AtomistSkillExecutionPlatform;
    publishedAt?: Maybe<Scalars['String']>;
    readme?: Maybe<Scalars['String']>;
    resourceProviders?: Maybe<Array<AtomistSkillResourceProviderSpec>>;
    schemata?: Maybe<Array<AtomistSkillIngestionSchema>>;
    subscriptions: Array<Scalars['String']>;
    technologies: Array<AtomistSkillTechnology>;
    version: Scalars['String'];
    videoUrl?: Maybe<Scalars['String']>;
};

type AtomistSkillArtifact

type AtomistSkillArtifact = {
    name: Scalars['ID'];
};

type AtomistSkillArtifactsInput

type AtomistSkillArtifactsInput = {
    docker?: Maybe<Array<AtomistDockerSkillArtifactInput>>;
    gcf?: Maybe<Array<AtomistGcfSkillArtifactInput>>;
};

type AtomistSkillBooleanParameterInput

type AtomistSkillBooleanParameterInput = {
    name: Scalars['String'];
    value: Scalars['Boolean'];
};

type AtomistSkillBooleanParameterSpec

type AtomistSkillBooleanParameterSpec = AtomistSkillParameterSpec & {
    __typename?: 'AtomistSkillBooleanParameterSpec';
    defaultValue?: Maybe<Scalars['Boolean']>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    required: Scalars['Boolean'];
    visibility: AtomistSkillParameterVisiblity;
};

type AtomistSkillBooleanParameterSpecInput

type AtomistSkillBooleanParameterSpecInput = {
    defaultValue?: Maybe<Scalars['Boolean']>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    required: Scalars['Boolean'];
    visibility?: Maybe<AtomistSkillParameterVisiblity>;
};

type AtomistSkillBooleanParameterValue

type AtomistSkillBooleanParameterValue = AtomistSkillParameterValue & {
    __typename?: 'AtomistSkillBooleanParameterValue';
    name: Scalars['String'];
    spec: AtomistSkillBooleanParameterSpec;
    value: Scalars['Boolean'];
};

type AtomistSkillCapabilitiesInput

type AtomistSkillCapabilitiesInput = {
    provides?: Maybe<Array<AtomistSkillProvidedCapabilityInput>>;
    requires?: Maybe<Array<AtomistSkillRequiredCapabilityInput>>;
};

type AtomistSkillCapabilitiesSpec

type AtomistSkillCapabilitiesSpec = {
    __typename?: 'AtomistSkillCapabilitiesSpec';
    provides: Array<AtomistSkillProvidedCapabilitySpec>;
    requires: Array<AtomistSkillRequiredCapabilitySpec>;
};

type AtomistSkillCapabilityProviderDetails

type AtomistSkillCapabilityProviderDetails = {
    __typename?: 'AtomistSkillCapabilityProviderDetails';
    configurationName: Scalars['String'];
    name: Scalars['String'];
    namespace: Scalars['String'];
};

type AtomistSkillCapabilityProviderInput

type AtomistSkillCapabilityProviderInput = {
    configurationName: Scalars['String'];
    name: Scalars['String'];
    namespace: Scalars['String'];
};

type AtomistSkillCapabilityProviders

type AtomistSkillCapabilityProviders = {
    __typename?: 'AtomistSkillCapabilityProviders';
    catalog: Array<RegisteredAtomistSkill>;
    configured: Array<ConfiguredAtomistSkill>;
    other: Array<RegisteredAtomistSkill>;
    owned: Array<RegisteredAtomistSkill>;
};

type AtomistSkillCapabilityProvidersInput

type AtomistSkillCapabilityProvidersInput = {
    name: Scalars['String'];
    namespace: Scalars['String'];
    providers: Array<AtomistSkillCapabilityProviderInput>;
    usage: Scalars['String'];
};

type AtomistSkillCapabilityProvidersOtherArgs

type AtomistSkillCapabilityProvidersOtherArgs = {
    maturities?: Maybe<Array<AtomistSkillMaturityLevel>>;
};

type AtomistSkillCapabilityProvidersOwnedArgs

type AtomistSkillCapabilityProvidersOwnedArgs = {
    maturities?: Maybe<Array<AtomistSkillMaturityLevel>>;
};

type AtomistSkillCapabilityProviderValue

type AtomistSkillCapabilityProviderValue = {
    __typename?: 'AtomistSkillCapabilityProviderValue';
    providers: Array<AtomistSkillCapabilityProviderDetails>;
    spec: AtomistSkillRequiredCapabilitySpec;
};

type AtomistSkillCategory

type AtomistSkillCategory = {
    __typename?: 'AtomistSkillCategory';
    key: AtomistSkillCategoryKey;
    sortOrder: Scalars['Int'];
    text: Scalars['String'];
};

type AtomistSkillChatChannelInput

type AtomistSkillChatChannelInput = {
    channelId: Scalars['String'];
    channelName: Scalars['String'];
    chatTeamId: Scalars['String'];
    resourceProviderId: Scalars['String'];
};

type AtomistSkillChatChannelParameterValue

type AtomistSkillChatChannelParameterValue = {
    __typename?: 'AtomistSkillChatChannelParameterValue';
    channelId: Scalars['String'];
    channelName: Scalars['String'];
    chatTeamId: Scalars['String'];
    resourceProviderId: Scalars['String'];
};

type AtomistSkillChatChannelsInput

type AtomistSkillChatChannelsInput = {
    name: Scalars['String'];
    value: Array<Maybe<AtomistSkillChatChannelInput>>;
};

type AtomistSkillChatChannelsParameterSpec

type AtomistSkillChatChannelsParameterSpec = AtomistSkillParameterSpec & {
    __typename?: 'AtomistSkillChatChannelsParameterSpec';
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    maxAllowed?: Maybe<Scalars['Int']>;
    minRequired?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    required: Scalars['Boolean'];
    visibility: AtomistSkillParameterVisiblity;
};

type AtomistSkillChatChannelsParameterSpecInput

type AtomistSkillChatChannelsParameterSpecInput = {
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    maxAllowed?: Maybe<Scalars['Int']>;
    minRequired?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    required: Scalars['Boolean'];
    visibility?: Maybe<AtomistSkillParameterVisiblity>;
};

type AtomistSkillChatChannelsParameterValue

type AtomistSkillChatChannelsParameterValue = AtomistSkillParameterValue & {
    __typename?: 'AtomistSkillChatChannelsParameterValue';
    name: Scalars['String'];
    spec: AtomistSkillChatChannelsParameterSpec;
    value: Array<AtomistSkillChatChannelParameterValue>;
};

type AtomistSkillChoice

type AtomistSkillChoice = {
    __typename?: 'AtomistSkillChoice';
    description?: Maybe<Scalars['String']>;
    text: Scalars['String'];
    value: Scalars['String'];
};

type AtomistSkillChoiceInput

type AtomistSkillChoiceInput = {
    description?: Maybe<Scalars['String']>;
    text: Scalars['String'];
    value: Scalars['String'];
};

type AtomistSkillConfiguration

type AtomistSkillConfiguration = {
    __typename?: 'AtomistSkillConfiguration';
    instances: Array<AtomistSkillConfigurationInstance>;
    repository: AtomistSkillConfigurationRepository;
    upgradePolicy: AtomistSkillUpgradePolicy;
};

type AtomistSkillConfigurationAuthor

type AtomistSkillConfigurationAuthor = {
    __typename?: 'AtomistSkillConfigurationAuthor';
    email: Scalars['String'];
    name: Scalars['String'];
};

type AtomistSkillConfigurationInput

type AtomistSkillConfigurationInput = {
    capabilities?: Maybe<Array<AtomistSkillCapabilityProvidersInput>>;
    displayName?: Maybe<Scalars['String']>;
    enabled: Scalars['Boolean'];
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['ID']>;
    parameters?: Maybe<Array<AtomistSkillParameterInput>>;
    resourceProviders?: Maybe<Array<AtomistSkillResourceProviderInput>>;
};

Configuration inputs

type AtomistSkillConfigurationInstance

type AtomistSkillConfigurationInstance = {
    __typename?: 'AtomistSkillConfigurationInstance';
    author: AtomistSkillConfigurationAuthor;
    capabilities?: Maybe<Array<AtomistSkillCapabilityProviderValue>>;
    displayName: Scalars['String'];
    enabled: Scalars['Boolean'];
    id: Scalars['ID'];
    name: Scalars['ID'];
    parameters?: Maybe<Array<AtomistSkillParameterValue>>;
    resourceProviders?: Maybe<Array<AtomistSkillResourceProviderValue>>;
    updatedAt: Scalars['String'];
};

type AtomistSkillConfigurationRepository

type AtomistSkillConfigurationRepository = {
    __typename?: 'AtomistSkillConfigurationRepository';
    commitSha: Scalars['String'];
};

type AtomistSkillDatalogSubscription

type AtomistSkillDatalogSubscription = {
    __typename?: 'AtomistSkillDatalogSubscription';
    name: Scalars['String'];
    query: Scalars['String'];
};

type AtomistSkillDatalogSubscriptionInput

type AtomistSkillDatalogSubscriptionInput = {
    name: Scalars['String'];
    query: Scalars['String'];
};

type AtomistSkillDockerArtifact

type AtomistSkillDockerArtifact = AtomistSkillArtifact & {
    __typename?: 'AtomistSkillDockerArtifact';
    args?: Maybe<Array<Scalars['String']>>;
    command?: Maybe<Array<Scalars['String']>>;
    env?: Maybe<Array<AtomistSkillEnvironmentVariable>>;
    image: Scalars['String'];
    name: Scalars['ID'];
    resources?: Maybe<AtomistSkillDockerResources>;
    workingDir?: Maybe<Scalars['String']>;
};

type AtomistSkillDockerResources

type AtomistSkillDockerResources = {
    __typename?: 'AtomistSkillDockerResources';
    limit?: Maybe<AtomistDockerSkillResourcesLimit>;
    request?: Maybe<AtomistDockerSkillResourcesRequest>;
};

type AtomistSkillDockerResourcesInput

type AtomistSkillDockerResourcesInput = {
    limit?: Maybe<AtomistSkillDockerResourcesLimitInput>;
    request?: Maybe<AtomistSkillDockerResourcesRequestInput>;
};

type AtomistSkillDockerResourcesLimitInput

type AtomistSkillDockerResourcesLimitInput = {
    /** kubenetes like cpu units */
    cpu?: Maybe<Scalars['Float']>;
    /** memory in megabytes */
    memory?: Maybe<Scalars['Int']>;
};

type AtomistSkillDockerResourcesRequestInput

type AtomistSkillDockerResourcesRequestInput = {
    /** kubenetes like cpu units */
    cpu?: Maybe<Scalars['Float']>;
    /** memory in megabytes */
    memory?: Maybe<Scalars['Int']>;
};

type AtomistSkillEnvironmentVariable

type AtomistSkillEnvironmentVariable = {
    __typename?: 'AtomistSkillEnvironmentVariable';
    name: Scalars['String'];
    value: Scalars['String'];
};

type AtomistSkillEnvVariableInput

type AtomistSkillEnvVariableInput = {
    name: Scalars['String'];
    value: Scalars['String'];
};

type AtomistSkillExecution

type AtomistSkillExecution = {
    __typename?: 'AtomistSkillExecution';
    context: AtomistSkillExecutionContext;
    endTime?: Maybe<Scalars['String']>;
    eventCorrelationId?: Maybe<Scalars['String']>;
    executionCorrelationId?: Maybe<Scalars['String']>;
    id: Scalars['ID'];
    logs: Array<AtomistSkillLog>;
    pagedLogs: AtomistSkillLogsPage;
    queueTime: Scalars['String'];
    skill: ConfiguredAtomistSkill;
    startTime?: Maybe<Scalars['String']>;
    status: AtomistSkillExecutionStatus;
    statusTime?: Maybe<Scalars['String']>;
    triggerCorrelationId: Scalars['String'];
    visibility: AtomistSkillExecutionVisibility;
};

type AtomistSkillExecutionContext

type AtomistSkillExecutionContext = {
    __typename?: 'AtomistSkillExecutionContext';
    configuration?: Maybe<AtomistSkillConfiguration>;
    triggerEvent: AtomistSkillExecutionTriggerEvent;
};

type AtomistSkillExecutionLogsArgs

type AtomistSkillExecutionLogsArgs = {
    _after?: Maybe<Scalars['String']>;
    _before?: Maybe<Scalars['String']>;
    _first?: Maybe<Scalars['Int']>;
    categories?: Maybe<Array<AtomistSkillExecutionLogCategory>>;
    category?: Maybe<AtomistSkillExecutionLogCategory>;
    severities?: Maybe<Array<AtomistSkillExecutionLogSeverity>>;
    severity?: Maybe<AtomistSkillExecutionLogSeverity>;
};

type AtomistSkillExecutionPagedLogsArgs

type AtomistSkillExecutionPagedLogsArgs = {
    filter?: Maybe<_AtomistSkillLogFilter>;
    first?: Maybe<Scalars['Int']>;
    pageKey?: Maybe<Scalars['String']>;
};

type AtomistSkillExecutionStatus

type AtomistSkillExecutionStatus = {
    __typename?: 'AtomistSkillExecutionStatus';
    message?: Maybe<Scalars['String']>;
    state: AtomistSkillExecutionState;
};

type AtomistSkillExecutionTriggerEvent

type AtomistSkillExecutionTriggerEvent = {
    __typename?: 'AtomistSkillExecutionTriggerEvent';
    name: Scalars['String'];
    type: AtomistSkillExecutionTriggerEventType;
};

type AtomistSkillFileFilterInput

type AtomistSkillFileFilterInput = {
    name: Scalars['String'];
    value: Array<Scalars['String']>;
};

type AtomistSkillFileFilterParameterSpec

type AtomistSkillFileFilterParameterSpec = AtomistSkillParameterSpec & {
    __typename?: 'AtomistSkillFileFilterParameterSpec';
    defaultValue?: Maybe<Array<Scalars['String']>>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    maxAllowed?: Maybe<Scalars['Int']>;
    minRequired?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    required: Scalars['Boolean'];
    visibility: AtomistSkillParameterVisiblity;
};

type AtomistSkillFileFilterParameterSpecInput

type AtomistSkillFileFilterParameterSpecInput = {
    defaultValue?: Maybe<Array<Maybe<Scalars['String']>>>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    maxAllowed?: Maybe<Scalars['Int']>;
    minRequired?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    required: Scalars['Boolean'];
    visibility?: Maybe<AtomistSkillParameterVisiblity>;
};

type AtomistSkillFileFilterParameterValue

type AtomistSkillFileFilterParameterValue = AtomistSkillParameterValue & {
    __typename?: 'AtomistSkillFileFilterParameterValue';
    name: Scalars['String'];
    spec: AtomistSkillFileFilterParameterSpec;
    value: Array<Scalars['String']>;
};

type AtomistSkillFloatParameterInput

type AtomistSkillFloatParameterInput = {
    name: Scalars['String'];
    value: Scalars['Float'];
};

type AtomistSkillFloatParameterSpec

type AtomistSkillFloatParameterSpec = AtomistSkillParameterSpec & {
    __typename?: 'AtomistSkillFloatParameterSpec';
    defaultValue?: Maybe<Scalars['Float']>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    maximum?: Maybe<Scalars['Float']>;
    minimum?: Maybe<Scalars['Float']>;
    name: Scalars['String'];
    placeHolder?: Maybe<Scalars['String']>;
    required: Scalars['Boolean'];
    visibility: AtomistSkillParameterVisiblity;
};

type AtomistSkillFloatParameterSpecInput

type AtomistSkillFloatParameterSpecInput = {
    defaultValue?: Maybe<Scalars['Float']>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    maximum?: Maybe<Scalars['Float']>;
    minimum?: Maybe<Scalars['Float']>;
    name: Scalars['String'];
    placeHolder?: Maybe<Scalars['String']>;
    required: Scalars['Boolean'];
    visibility?: Maybe<AtomistSkillParameterVisiblity>;
};

type AtomistSkillFloatParameterValue

type AtomistSkillFloatParameterValue = AtomistSkillParameterValue & {
    __typename?: 'AtomistSkillFloatParameterValue';
    name: Scalars['String'];
    spec: AtomistSkillFloatParameterSpec;
    value: Scalars['Float'];
};

type AtomistSkillGcfArtifact

type AtomistSkillGcfArtifact = AtomistSkillArtifact & {
    __typename?: 'AtomistSkillGCFArtifact';
    entryPoint: Scalars['String'];
    memory: Scalars['Int'];
    name: Scalars['ID'];
    runtime: AtomistSkillRuntime;
    timeout: Scalars['Int'];
    url: Scalars['String'];
};

type AtomistSkillIngestionSchema

type AtomistSkillIngestionSchema = {
    __typename?: 'AtomistSkillIngestionSchema';
    name: Scalars['String'];
    schema: Scalars['String'];
};

type AtomistSkillIngestionSchemaInput

type AtomistSkillIngestionSchemaInput = {
    name: Scalars['String'];
    schema: Scalars['String'];
};

Start: registration inputs

type AtomistSkillInput

type AtomistSkillInput = {
    artifacts: AtomistSkillArtifactsInput;
    author: Scalars['String'];
    branchId?: Maybe<Scalars['String']>;
    capabilities?: Maybe<AtomistSkillCapabilitiesInput>;
    categories?: Maybe<Array<AtomistSkillCategoryKey>>;
    commands?: Maybe<Array<AtomistChatCommandInput>>;
    commitSha: Scalars['String'];
    datalogSubscriptions?: Maybe<Array<AtomistSkillDatalogSubscriptionInput>>;
    description: Scalars['String'];
    dispatchStyle?: Maybe<AtomistSkillEventDispatchStyle>;
    displayName?: Maybe<Scalars['String']>;
    homepageUrl: Scalars['String'];
    iconUrl: Scalars['String'];
    ingesters?: Maybe<Array<Scalars['String']>>;
    integration?: Maybe<Scalars['Boolean']>;
    license: Scalars['String'];
    longDescription: Scalars['String'];
    maturity?: Maybe<AtomistSkillMaturityLevel>;
    maxConfigurations?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    namespace: Scalars['String'];
    parameters?: Maybe<Array<AtomistSkillParameterSpecInput>>;
    readme?: Maybe<Scalars['String']>;
    repoId: Scalars['String'];
    resourceProviders?: Maybe<Array<AtomistSkillResourceProviderSpecInput>>;
    schemata?: Maybe<Array<AtomistSkillIngestionSchemaInput>>;
    subscriptions?: Maybe<Array<Scalars['String']>>;
    technologies?: Maybe<Array<AtomistSkillTechnology>>;
    version: Scalars['String'];
    videoUrl?: Maybe<Scalars['String']>;
};

type AtomistSkillIntParameterInput

type AtomistSkillIntParameterInput = {
    name: Scalars['String'];
    value: Scalars['Int'];
};

type AtomistSkillIntParameterSpec

type AtomistSkillIntParameterSpec = AtomistSkillParameterSpec & {
    __typename?: 'AtomistSkillIntParameterSpec';
    defaultValue?: Maybe<Scalars['Int']>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    maximum?: Maybe<Scalars['Int']>;
    minimum?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    placeHolder?: Maybe<Scalars['String']>;
    required: Scalars['Boolean'];
    visibility: AtomistSkillParameterVisiblity;
};

type AtomistSkillIntParameterSpecInput

type AtomistSkillIntParameterSpecInput = {
    defaultValue?: Maybe<Scalars['Int']>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    maximum?: Maybe<Scalars['Int']>;
    minimum?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    placeHolder?: Maybe<Scalars['String']>;
    required: Scalars['Boolean'];
    visibility?: Maybe<AtomistSkillParameterVisiblity>;
};

type AtomistSkillIntParameterValue

type AtomistSkillIntParameterValue = AtomistSkillParameterValue & {
    __typename?: 'AtomistSkillIntParameterValue';
    name: Scalars['String'];
    spec: AtomistSkillIntParameterSpec;
    value: Scalars['Int'];
};

type AtomistSkillLog

type AtomistSkillLog = {
    __typename?: 'AtomistSkillLog';
    category: Scalars['String'];
    id: Scalars['String'];
    payload: Scalars['String'];
    severity: Scalars['String'];
    timestamp: Scalars['String'];
};

type AtomistSkillLogsPage

type AtomistSkillLogsPage = {
    __typename?: 'AtomistSkillLogsPage';
    logs: Array<AtomistSkillLog>;
    nextPageKey?: Maybe<Scalars['String']>;
};

type AtomistSkillMultiChoiceParameterInput

type AtomistSkillMultiChoiceParameterInput = {
    name: Scalars['String'];
    value: Array<Scalars['String']>;
};

type AtomistSkillMultiChoiceParameterSpec

type AtomistSkillMultiChoiceParameterSpec = AtomistSkillParameterSpec & {
    __typename?: 'AtomistSkillMultiChoiceParameterSpec';
    defaultValues?: Maybe<Array<Scalars['String']>>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    maxAllowed?: Maybe<Scalars['Int']>;
    minRequired?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    options?: Maybe<Array<AtomistSkillChoice>>;
    required: Scalars['Boolean'];
    visibility: AtomistSkillParameterVisiblity;
};

type AtomistSkillMultiChoiceParameterSpecInput

type AtomistSkillMultiChoiceParameterSpecInput = {
    defaultValues?: Maybe<Array<Scalars['String']>>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    maxAllowed?: Maybe<Scalars['Int']>;
    minRequired?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    options?: Maybe<Array<AtomistSkillChoiceInput>>;
    required: Scalars['Boolean'];
    visibility?: Maybe<AtomistSkillParameterVisiblity>;
};

type AtomistSkillMultiChoiceParameterValues

type AtomistSkillMultiChoiceParameterValues = AtomistSkillParameterValue & {
    __typename?: 'AtomistSkillMultiChoiceParameterValues';
    name: Scalars['String'];
    spec: AtomistSkillMultiChoiceParameterSpec;
    value: Array<Scalars['String']>;
};

type AtomistSkillParameterInput

type AtomistSkillParameterInput = {
    boolean?: Maybe<AtomistSkillBooleanParameterInput>;
    chatChannels?: Maybe<AtomistSkillChatChannelsInput>;
    fileFilter?: Maybe<AtomistSkillFileFilterInput>;
    float?: Maybe<AtomistSkillFloatParameterInput>;
    int?: Maybe<AtomistSkillIntParameterInput>;
    multiChoice?: Maybe<AtomistSkillMultiChoiceParameterInput>;
    repoFilter?: Maybe<AtomistSkillRepoFiltersInput>;
    schedule?: Maybe<AtomistSkillScheduleInput>;
    secret?: Maybe<AtomistSkillSecretParameterInput>;
    singleChoice?: Maybe<AtomistSkillSingleChoiceParameterInput>;
    string?: Maybe<AtomistSkillStringParameterInput>;
    stringArray?: Maybe<AtomistSkillStringArrayParameterInput>;
    webhook?: Maybe<AtomistSkillWebhookParameterInput>;
};

type AtomistSkillParameterSpec

type AtomistSkillParameterSpec = {
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    required: Scalars['Boolean'];
};

type AtomistSkillParameterSpecInput

type AtomistSkillParameterSpecInput = {
    boolean?: Maybe<AtomistSkillBooleanParameterSpecInput>;
    chatChannels?: Maybe<AtomistSkillChatChannelsParameterSpecInput>;
    fileFilter?: Maybe<AtomistSkillFileFilterParameterSpecInput>;
    float?: Maybe<AtomistSkillFloatParameterSpecInput>;
    int?: Maybe<AtomistSkillIntParameterSpecInput>;
    multiChoice?: Maybe<AtomistSkillMultiChoiceParameterSpecInput>;
    repoFilter?: Maybe<AtomistSkillRepoFilterParameterSpecInput>;
    schedule?: Maybe<AtomistSkillScheduleParameterSpecInput>;
    secret?: Maybe<AtomistSkillSecretParameterSpecInput>;
    singleChoice?: Maybe<AtomistSkillSingleChoiceParameterSpecInput>;
    string?: Maybe<AtomistSkillStringParameterSpecInput>;
    stringArray?: Maybe<AtomistSkillStringArrayParameterSpecInput>;
    webhook?: Maybe<AtomistSkillWebhookParameterSpecInput>;
};

type AtomistSkillParameterValue

type AtomistSkillParameterValue = {
    name: Scalars['String'];
    spec: AtomistSkillParameterSpec;
};

type AtomistSkillProvidedCapabilityInput

type AtomistSkillProvidedCapabilityInput = {
    name: Scalars['String'];
    namespace?: Maybe<Scalars['String']>;
};

type AtomistSkillProvidedCapabilitySpec

type AtomistSkillProvidedCapabilitySpec = {
    __typename?: 'AtomistSkillProvidedCapabilitySpec';
    name: Scalars['String'];
    namespace: Scalars['String'];
};

type AtomistSkillRepoFilterInclusionParameterValue

type AtomistSkillRepoFilterInclusionParameterValue = {
    __typename?: 'AtomistSkillRepoFilterInclusionParameterValue';
    excludes?: Maybe<Array<AtomistSkillRepoFilterParameterValueDetail>>;
    includes?: Maybe<Array<AtomistSkillRepoFilterParameterValueDetail>>;
};

type AtomistSkillRepoFilterInput

type AtomistSkillRepoFilterInput = {
    ownerId: Scalars['String'];
    providerId: Scalars['String'];
    repoIds: Array<Scalars['String']>;
};

type AtomistSkillRepoFilterParameterSpecInput

type AtomistSkillRepoFilterParameterSpecInput = {
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    required: Scalars['Boolean'];
};

type AtomistSkillRepoFilterParameterValue

type AtomistSkillRepoFilterParameterValue = AtomistSkillParameterValue & {
    __typename?: 'AtomistSkillRepoFilterParameterValue';
    name: Scalars['String'];
    spec: AtomistSkillRepoFilterSpec;
    value: AtomistSkillRepoFilterInclusionParameterValue;
};

type AtomistSkillRepoFilterParameterValueDetail

type AtomistSkillRepoFilterParameterValueDetail = {
    __typename?: 'AtomistSkillRepoFilterParameterValueDetail';
    ownerId: Scalars['String'];
    providerId: Scalars['String'];
    repoIds: Array<Scalars['String']>;
};

type AtomistSkillRepoFiltersInput

type AtomistSkillRepoFiltersInput = {
    name: Scalars['String'];
    value: AtomistSkillRepoFiltersValueInput;
};

type AtomistSkillRepoFilterSpec

type AtomistSkillRepoFilterSpec = AtomistSkillParameterSpec & {
    __typename?: 'AtomistSkillRepoFilterSpec';
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    required: Scalars['Boolean'];
};

type AtomistSkillRepoFiltersValueInput

type AtomistSkillRepoFiltersValueInput = {
    excludes?: Maybe<Array<AtomistSkillRepoFilterInput>>;
    includes?: Maybe<Array<AtomistSkillRepoFilterInput>>;
};

type AtomistSkillRequiredCapabilityInput

type AtomistSkillRequiredCapabilityInput = {
    description?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    maxAllowed?: Maybe<Scalars['Int']>;
    minRequired?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    namespace?: Maybe<Scalars['String']>;
    scopes: Array<AtomistSkillRequiredCapabilityScope>;
    usage: Scalars['String'];
};

type AtomistSkillRequiredCapabilitySpec

type AtomistSkillRequiredCapabilitySpec = {
    __typename?: 'AtomistSkillRequiredCapabilitySpec';
    description?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    maxAllowed?: Maybe<Scalars['Int']>;
    minRequired?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    namespace: Scalars['String'];
    providers: AtomistSkillCapabilityProviders;
    scopes: Array<AtomistSkillRequiredCapabilityScope>;
    usage: Scalars['String'];
};

type AtomistSkillResourceProviderInput

type AtomistSkillResourceProviderInput = {
    name: Scalars['String'];
    selectedResourceProviders?: Maybe<
        Array<AtomistSkillSelectedResourceProviderInput>
    >;
};

type AtomistSkillResourceProviderSpec

type AtomistSkillResourceProviderSpec = {
    __typename?: 'AtomistSkillResourceProviderSpec';
    description?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    maxAllowed?: Maybe<Scalars['Int']>;
    minRequired?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    typeName: Scalars['String'];
};

type AtomistSkillResourceProviderSpecInput

type AtomistSkillResourceProviderSpecInput = {
    description?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    maxAllowed?: Maybe<Scalars['Int']>;
    minRequired?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    typeName: Scalars['String'];
};

type AtomistSkillResourceProviderValue

type AtomistSkillResourceProviderValue = {
    __typename?: 'AtomistSkillResourceProviderValue';
    displayName?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    selectedResourceProviders: Array<AtomistSkillSelectedResourceProvider>;
    typeName: Scalars['String'];
};

type AtomistSkills

type AtomistSkills = {
    __typename?: 'AtomistSkills';
    configured: AtomistPagedConfiguredSkills;
    owned: AtomistPagedRegisteredSkills;
};

type AtomistSkillScheduleInput

type AtomistSkillScheduleInput = {
    name: Scalars['String'];
    value: AtomistSkillScheduleValueInput;
};

type AtomistSkillScheduleParameterSpec

type AtomistSkillScheduleParameterSpec = AtomistSkillParameterSpec & {
    __typename?: 'AtomistSkillScheduleParameterSpec';
    defaultValue?: Maybe<Scalars['String']>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    required: Scalars['Boolean'];
    visibility: AtomistSkillParameterVisiblity;
};

type AtomistSkillScheduleParameterSpecInput

type AtomistSkillScheduleParameterSpecInput = {
    defaultValue?: Maybe<Scalars['String']>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    required: Scalars['Boolean'];
    visibility?: Maybe<AtomistSkillParameterVisiblity>;
};

type AtomistSkillScheduleParameterValue

type AtomistSkillScheduleParameterValue = AtomistSkillParameterValue & {
    __typename?: 'AtomistSkillScheduleParameterValue';
    name: Scalars['String'];
    spec: AtomistSkillScheduleParameterSpec;
    value: AtomistSkillScheduleParameterValueDetail;
};

type AtomistSkillScheduleParameterValueDetail

type AtomistSkillScheduleParameterValueDetail = {
    __typename?: 'AtomistSkillScheduleParameterValueDetail';
    cronExpression: Scalars['String'];
    timeZone?: Maybe<Scalars['String']>;
};

type AtomistSkillScheduleValueInput

type AtomistSkillScheduleValueInput = {
    cronExpression: Scalars['String'];
    timeZone?: Maybe<Scalars['String']>;
};

type AtomistSkillsConfiguredArgs

type AtomistSkillsConfiguredArgs = {
    query?: Maybe<AtomistSkillsSearchInput>;
};

type AtomistSkillSecretParameterInput

type AtomistSkillSecretParameterInput = {
    name: Scalars['String'];
    value: Scalars['String'];
};

type AtomistSkillSecretParameterSpec

type AtomistSkillSecretParameterSpec = AtomistSkillParameterSpec & {
    __typename?: 'AtomistSkillSecretParameterSpec';
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    lineStyle: AtomistSkillStringParameterLineStyle;
    name: Scalars['String'];
    required: Scalars['Boolean'];
    visibility: AtomistSkillParameterVisiblity;
};

type AtomistSkillSecretParameterSpecInput

type AtomistSkillSecretParameterSpecInput = {
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    lineStyle?: Maybe<AtomistSkillStringParameterLineStyle>;
    name: Scalars['String'];
    required: Scalars['Boolean'];
    visibility?: Maybe<AtomistSkillParameterVisiblity>;
};

type AtomistSkillSecretParameterValue

type AtomistSkillSecretParameterValue = AtomistSkillParameterValue & {
    __typename?: 'AtomistSkillSecretParameterValue';
    name: Scalars['String'];
    spec: AtomistSkillSecretParameterSpec;
    value: Scalars['String'];
};

type AtomistSkillSelectedResourceProvider

type AtomistSkillSelectedResourceProvider = {
    __typename?: 'AtomistSkillSelectedResourceProvider';
    id: Scalars['String'];
};

type AtomistSkillSelectedResourceProviderInput

type AtomistSkillSelectedResourceProviderInput = {
    id: Scalars['String'];
};

type AtomistSkillSingleChoiceParameterInput

type AtomistSkillSingleChoiceParameterInput = {
    name: Scalars['String'];
    value: Scalars['String'];
};

type AtomistSkillSingleChoiceParameterSpec

type AtomistSkillSingleChoiceParameterSpec = AtomistSkillParameterSpec & {
    __typename?: 'AtomistSkillSingleChoiceParameterSpec';
    defaultValue?: Maybe<Scalars['String']>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    options?: Maybe<Array<AtomistSkillChoice>>;
    required: Scalars['Boolean'];
    visibility: AtomistSkillParameterVisiblity;
};

type AtomistSkillSingleChoiceParameterSpecInput

type AtomistSkillSingleChoiceParameterSpecInput = {
    defaultValue?: Maybe<Scalars['String']>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    options?: Maybe<Array<AtomistSkillChoiceInput>>;
    required: Scalars['Boolean'];
    visibility?: Maybe<AtomistSkillParameterVisiblity>;
};

type AtomistSkillSingleChoiceParameterValue

type AtomistSkillSingleChoiceParameterValue = AtomistSkillParameterValue & {
    __typename?: 'AtomistSkillSingleChoiceParameterValue';
    name: Scalars['String'];
    spec: AtomistSkillSingleChoiceParameterSpec;
    value: Scalars['String'];
};

type AtomistSkillsOwnedArgs

type AtomistSkillsOwnedArgs = {
    query?: Maybe<AtomistSkillsSearchInput>;
};

type AtomistSkillsSearchInput

type AtomistSkillsSearchInput = {
    name?: Maybe<Scalars['String']>;
    namespace?: Maybe<Scalars['String']>;
    showDerived?: Maybe<Scalars['Boolean']>;
    version?: Maybe<Scalars['String']>;
};

type AtomistSkillStatus

type AtomistSkillStatus = {
    __typename?: 'AtomistSkillStatus';
    code: AtomistSkillStatusCode;
    message?: Maybe<Scalars['String']>;
};

type AtomistSkillStringArrayParameterInput

type AtomistSkillStringArrayParameterInput = {
    name: Scalars['String'];
    value: Array<Scalars['String']>;
};

type AtomistSkillStringArrayParameterSpec

type AtomistSkillStringArrayParameterSpec = AtomistSkillParameterSpec & {
    __typename?: 'AtomistSkillStringArrayParameterSpec';
    defaultValue?: Maybe<Array<Scalars['String']>>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    maxAllowed?: Maybe<Scalars['Int']>;
    minRequired?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    pattern?: Maybe<Scalars['String']>;
    required: Scalars['Boolean'];
    visibility: AtomistSkillParameterVisiblity;
};

type AtomistSkillStringArrayParameterSpecInput

type AtomistSkillStringArrayParameterSpecInput = {
    defaultValue?: Maybe<Array<Maybe<Scalars['String']>>>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    maxAllowed?: Maybe<Scalars['Int']>;
    minRequired?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    pattern?: Maybe<Scalars['String']>;
    required: Scalars['Boolean'];
    visibility?: Maybe<AtomistSkillParameterVisiblity>;
};

type AtomistSkillStringArrayParameterValue

type AtomistSkillStringArrayParameterValue = AtomistSkillParameterValue & {
    __typename?: 'AtomistSkillStringArrayParameterValue';
    name: Scalars['String'];
    spec: AtomistSkillStringArrayParameterSpec;
    value: Array<Scalars['String']>;
};

type AtomistSkillStringParameterInput

type AtomistSkillStringParameterInput = {
    name: Scalars['String'];
    value: Scalars['String'];
};

type AtomistSkillStringParameterSpec

type AtomistSkillStringParameterSpec = AtomistSkillParameterSpec & {
    __typename?: 'AtomistSkillStringParameterSpec';
    defaultValue?: Maybe<Scalars['String']>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    lineStyle: AtomistSkillStringParameterLineStyle;
    name: Scalars['String'];
    pattern?: Maybe<Scalars['String']>;
    placeHolder?: Maybe<Scalars['String']>;
    required: Scalars['Boolean'];
    visibility: AtomistSkillParameterVisiblity;
};

type AtomistSkillStringParameterSpecInput

type AtomistSkillStringParameterSpecInput = {
    defaultValue?: Maybe<Scalars['String']>;
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    lineStyle?: Maybe<AtomistSkillStringParameterLineStyle>;
    name: Scalars['String'];
    pattern?: Maybe<Scalars['String']>;
    placeHolder?: Maybe<Scalars['String']>;
    required: Scalars['Boolean'];
    visibility?: Maybe<AtomistSkillParameterVisiblity>;
};

type AtomistSkillStringParameterValue

type AtomistSkillStringParameterValue = AtomistSkillParameterValue & {
    __typename?: 'AtomistSkillStringParameterValue';
    name: Scalars['String'];
    spec: AtomistSkillStringParameterSpec;
    value: Scalars['String'];
};

type AtomistSkillWebhookParameterInput

type AtomistSkillWebhookParameterInput = {
    name: Scalars['String'];
    value: Array<AtomistSkillWebhookParameterValueInput>;
};

type AtomistSkillWebhookParameterSpec

type AtomistSkillWebhookParameterSpec = AtomistSkillParameterSpec & {
    __typename?: 'AtomistSkillWebhookParameterSpec';
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    maxAllowed?: Maybe<Scalars['Int']>;
    minRequired?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    required: Scalars['Boolean'];
    visibility?: Maybe<AtomistSkillParameterVisiblity>;
};

type AtomistSkillWebhookParameterSpecInput

type AtomistSkillWebhookParameterSpecInput = {
    description: Scalars['String'];
    displayName?: Maybe<Scalars['String']>;
    maxAllowed?: Maybe<Scalars['Int']>;
    minRequired?: Maybe<Scalars['Int']>;
    name: Scalars['String'];
    required: Scalars['Boolean'];
    visibility?: Maybe<AtomistSkillParameterVisiblity>;
};

type AtomistSkillWebhookParameterValue

type AtomistSkillWebhookParameterValue = AtomistSkillParameterValue & {
    __typename?: 'AtomistSkillWebhookParameterValue';
    name: Scalars['String'];
    spec: AtomistSkillWebhookParameterSpec;
    value: Array<AtomistSkillWebhookParameterValueDetail>;
};

type AtomistSkillWebhookParameterValueDetail

type AtomistSkillWebhookParameterValueDetail = {
    __typename?: 'AtomistSkillWebhookParameterValueDetail';
    name: Scalars['String'];
    url: Scalars['String'];
};

type AtomistSkillWebhookParameterValueInput

type AtomistSkillWebhookParameterValueInput = {
    name: Scalars['String'];
};

type BinaryRepositoryProvider

type BinaryRepositoryProvider = ResourceProvider & {
    __typename?: 'BinaryRepositoryProvider';
    name: Scalars['String'];
    type: BinaryRepositoryType;
    providerId: Scalars['String'];
    url?: Maybe<Scalars['String']>;
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    _id: Scalars['Int'];
    id: Scalars['ID'];
    team: Team;
    authProviderId?: Maybe<Scalars['String']>;
    state?: Maybe<ResourceProviderState>;
    credential?: Maybe<Credential>;
    webhooks?: Maybe<Array<Maybe<Webhook>>>;
    createdAt: Scalars['String'];
    updatedAt: Scalars['String'];
    createdBy?: Maybe<Person>;
    updatedBy?: Maybe<Person>;
    metadata?: Maybe<ResourceProviderMetadata>;
};

type BinaryRepositoryProviderQuery

type BinaryRepositoryProviderQuery = {
    __typename?: 'Query';
} & {
    BinaryRepositoryProvider?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'BinaryRepositoryProvider';
                } & Pick<BinaryRepositoryProvider, 'url' | 'name'> & {
                        state?: Maybe<
                            {
                                __typename?: 'ResourceProviderState';
                            } & Pick<ResourceProviderState, 'error' | 'name'>
                        >;
                        credential?: Maybe<
                            | ({
                                  __typename?: 'OAuthToken';
                              } & Pick<OAuthToken, 'id'> & {
                                      owner: {
                                          __typename?: 'SCMId';
                                      } & Pick<ScmId, 'login'>;
                                  })
                            | ({
                                  __typename?: 'Password';
                              } & Pick<Password, 'id'> & {
                                      owner:
                                          | ({
                                                __typename?: 'SCMId';
                                            } & Pick<ScmId, 'login'>)
                                          | ({
                                                __typename?: 'GitHubId';
                                            } & Pick<GitHubId, 'login'>)
                                          | ({
                                                __typename?: 'GitHubAppResourceUser';
                                            } & Pick<GitHubAppResourceUser, 'login'>)
                                          | ({
                                                __typename?: 'GenericResourceUser';
                                            } & Pick<GenericResourceUser, 'login'>)
                                          | ({
                                                __typename?: 'SystemAccount';
                                            } & Pick<SystemAccount, 'login'>);
                                  })
                        >;
                    }
            >
        >
    >;
};

type BinaryRepositoryProviderQueryVariables

type BinaryRepositoryProviderQueryVariables = {
    name?: Maybe<Scalars['String']>;
    type?: Maybe<BinaryRepositoryType>;
};

type BinaryRepositoryProviderWebhooksArgs

type BinaryRepositoryProviderWebhooksArgs = {
    id?: Maybe<Scalars['ID']>;
};

type Branch

type Branch = {
    __typename?: 'Branch';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** the URL of the Branch */
    url?: Maybe<Scalars['String']>;
    /** id of  Branch */
    id?: Maybe<Scalars['ID']>;
    /** name of  Branch */
    name?: Maybe<Scalars['String']>;
    /** timestamp of  Branch */
    timestamp?: Maybe<Scalars['String']>;
    /** isRemote of  Branch */
    isRemote?: Maybe<Scalars['Boolean']>;
    /** remoteRepoHtmlUrl of  Branch */
    remoteRepoHtmlUrl?: Maybe<Scalars['String']>;
    /** Branch repo Repo */
    repo?: Maybe<Repo>;
    /** Branch commit Commit */
    commit?: Maybe<Commit>;
    /** Branch pullRequests PullRequest */
    pullRequests?: Maybe<Array<Maybe<PullRequest>>>;
};

Branch-Node

type BranchCommitArgs

type BranchCommitArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

Branch-Node

type BranchForNameQuery

type BranchForNameQuery = {
    __typename?: 'Query';
} & {
    Branch?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Branch';
                } & Pick<Branch, 'id'> & {
                        repo?: Maybe<
                            {
                                __typename?: 'Repo';
                            } & Pick<Repo, 'id'>
                        >;
                    }
            >
        >
    >;
};

type BranchForNameQueryVariables

type BranchForNameQueryVariables = {
    repo: Scalars['String'];
    owner: Scalars['String'];
    branch: Scalars['String'];
};

type BranchPullRequestsArgs

type BranchPullRequestsArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    prId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    merged?: Maybe<Scalars['Boolean']>;
    timestamp?: Maybe<Scalars['String']>;
    baseBranchName?: Maybe<Scalars['String']>;
    branchName?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    closedAt?: Maybe<Scalars['String']>;
    mergedAt?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_PullRequestOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    mergeStatus?: Maybe<MergeStatus>;
};

Branch-Node

type BranchRepoArgs

type BranchRepoArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    allowRebaseMerge?: Maybe<Scalars['Boolean']>;
    allowSquashMerge?: Maybe<Scalars['Boolean']>;
    allowMergeCommit?: Maybe<Scalars['Boolean']>;
    repoId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    defaultBranch?: Maybe<Scalars['String']>;
};

Branch-Node

type Build

type Build = {
    __typename?: 'Build';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** id of  Build */
    id?: Maybe<Scalars['ID']>;
    /** buildId of  Build */
    buildId?: Maybe<Scalars['String']>;
    /** number of  Build */
    number?: Maybe<Scalars['Int']>;
    /** name of  Build */
    name?: Maybe<Scalars['String']>;
    /** status of  Build */
    status?: Maybe<BuildStatus>;
    /** buildUrl of  Build */
    buildUrl?: Maybe<Scalars['String']>;
    /** compareUrl of  Build */
    compareUrl?: Maybe<Scalars['String']>;
    /** trigger of  Build */
    trigger?: Maybe<BuildTrigger>;
    /** provider of  Build */
    provider?: Maybe<Scalars['String']>;
    /** pullRequestNumber of  Build */
    pullRequestNumber?: Maybe<Scalars['Float']>;
    /** startedAt of  Build */
    startedAt?: Maybe<Scalars['String']>;
    /** finishedAt of  Build */
    finishedAt?: Maybe<Scalars['String']>;
    /** timestamp of  Build */
    timestamp?: Maybe<Scalars['String']>;
    /** workflowId of  Build */
    workflowId?: Maybe<Scalars['String']>;
    /** jobName of  Build */
    jobName?: Maybe<Scalars['String']>;
    /** jobId of  Build */
    jobId?: Maybe<Scalars['String']>;
    /** data of  Build */
    data?: Maybe<Scalars['String']>;
    /** Build repo Repo */
    repo?: Maybe<Repo>;
    /** Build push Push */
    push?: Maybe<Push>;
    /** Build pullRequest PullRequest */
    pullRequest?: Maybe<PullRequest>;
    /** Build tag Tag */
    tag?: Maybe<Tag>;
    /** Build commit Commit */
    commit?: Maybe<Commit>;
    /** Build workflow Workflow */
    workflow?: Maybe<Workflow>;
};

Build-Node

type BuildCommitArgs

type BuildCommitArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

Build-Node

type BuildListener

type BuildListener = SdmListener<BuildListenerInvocation>;

type BuildPullRequestArgs

type BuildPullRequestArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    prId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    merged?: Maybe<Scalars['Boolean']>;
    timestamp?: Maybe<Scalars['String']>;
    baseBranchName?: Maybe<Scalars['String']>;
    branchName?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    closedAt?: Maybe<Scalars['String']>;
    mergedAt?: Maybe<Scalars['String']>;
    mergeStatus?: Maybe<MergeStatus>;
};

Build-Node

type BuildPushArgs

type BuildPushArgs = {
    id?: Maybe<Scalars['ID']>;
    timestamp?: Maybe<Scalars['String']>;
    branch?: Maybe<Scalars['String']>;
};

Build-Node

type BuildRepoArgs

type BuildRepoArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    allowRebaseMerge?: Maybe<Scalars['Boolean']>;
    allowSquashMerge?: Maybe<Scalars['Boolean']>;
    allowMergeCommit?: Maybe<Scalars['Boolean']>;
    repoId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    defaultBranch?: Maybe<Scalars['String']>;
};

Build-Node

type BuildTagArgs

type BuildTagArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    ref?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

Build-Node

type BuildUrlByShaQuery

type BuildUrlByShaQuery = {
    __typename?: 'Query';
} & {
    Commit?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Commit';
                } & {
                    builds?: Maybe<
                        Array<
                            Maybe<
                                {
                                    __typename?: 'Build';
                                } & Pick<Build, 'status' | 'buildUrl' | 'timestamp'>
                            >
                        >
                    >;
                }
            >
        >
    >;
};

type BuildUrlByShaQueryVariables

type BuildUrlByShaQueryVariables = {
    sha: Scalars['String'];
};

type BuildWorkflowArgs

type BuildWorkflowArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    workflowId?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    config?: Maybe<Scalars['String']>;
};

Build-Node

type CanceledSdmGoalQuery

type CanceledSdmGoalQuery = {
    __typename?: 'Query';
} & {
    SdmGoal?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SdmGoal';
                } & Pick<SdmGoal, 'id'>
            >
        >
    >;
};

type CanceledSdmGoalQueryVariables

type CanceledSdmGoalQueryVariables = {
    goalSetId: Scalars['String'];
    uniqueName: Scalars['String'];
};

type Card

type Card = {
    __typename?: 'Card';
    actionGroups?: Maybe<Array<Maybe<CardActionGroup>>>;
    actions?: Maybe<Array<Maybe<CardAction>>>;
    body?: Maybe<CardBody>;
    collaborators?: Maybe<Array<Maybe<CardCollaborator>>>;
    comments?: Maybe<Array<Maybe<CardBody>>>;
    correlations?: Maybe<Array<Maybe<CardCorrelation>>>;
    events?: Maybe<Array<Maybe<CardEvent>>>;
    goalSets?: Maybe<Array<Maybe<CardSdmGoalSet>>>;
    key?: Maybe<Scalars['String']>;
    post?: Maybe<Scalars['String']>;
    provenance?: Maybe<Array<Maybe<CardProvenance>>>;
    reactions?: Maybe<Array<Maybe<CardReaction>>>;
    repository?: Maybe<CardRepository>;
    shortTitle?: Maybe<Scalars['String']>;
    title?: Maybe<CardTitle>;
    ts?: Maybe<Scalars['Int']>;
    ttl?: Maybe<Scalars['Int']>;
    type?: Maybe<Scalars['String']>;
    /** The ID of this Card */
    id?: Maybe<Scalars['ID']>;
};

type CardAction

type CardAction = {
    __typename?: 'CardAction';
    command?: Maybe<Scalars['String']>;
    confirm?: Maybe<CardActionConfirmation>;
    parameterName?: Maybe<Scalars['String']>;
    parameterOptionGroups?: Maybe<Array<Maybe<CardActionParameterOptionGroup>>>;
    parameterOptions?: Maybe<Array<Maybe<CardActionParameterOption>>>;
    parameters?: Maybe<Array<Maybe<CardActionParameter>>>;
    registration?: Maybe<Scalars['String']>;
    role?: Maybe<Scalars['String']>;
    text?: Maybe<Scalars['String']>;
    type?: Maybe<Scalars['String']>;
};

type CardActionConfirmation

type CardActionConfirmation = {
    __typename?: 'CardActionConfirmation';
    body?: Maybe<Scalars['String']>;
    dismiss?: Maybe<Scalars['String']>;
    ok?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
};

type CardActionGroup

type CardActionGroup = {
    __typename?: 'CardActionGroup';
    actions?: Maybe<Array<Maybe<CardAction>>>;
    text?: Maybe<Scalars['String']>;
};

type CardActionParameter

type CardActionParameter = {
    __typename?: 'CardActionParameter';
    name?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
};

type CardActionParameterOption

type CardActionParameterOption = {
    __typename?: 'CardActionParameterOption';
    name?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
};

type CardActionParameterOptionGroup

type CardActionParameterOptionGroup = {
    __typename?: 'CardActionParameterOptionGroup';
    name?: Maybe<Scalars['String']>;
    options?: Maybe<Array<Maybe<CardActionParameterOption>>>;
};

type CardBody

type CardBody = {
    __typename?: 'CardBody';
    avatar?: Maybe<Scalars['String']>;
    hint?: Maybe<Scalars['String']>;
    login?: Maybe<Scalars['String']>;
    text?: Maybe<Scalars['String']>;
    ts?: Maybe<Scalars['Int']>;
};

type CardCollaborator

type CardCollaborator = {
    __typename?: 'CardCollaborator';
    avatar?: Maybe<Scalars['String']>;
    link?: Maybe<Scalars['String']>;
    login?: Maybe<Scalars['String']>;
};

type CardCollaboratorsArgs

type CardCollaboratorsArgs = {
    login?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type CardCorrelation

type CardCorrelation = {
    __typename?: 'CardCorrelation';
    body?: Maybe<Array<Maybe<CorrelationBody>>>;
    icon?: Maybe<Scalars['String']>;
    link?: Maybe<Scalars['String']>;
    shortTitle?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    ts?: Maybe<Scalars['Int']>;
    type?: Maybe<Scalars['String']>;
};

type CardEvent

type CardEvent = {
    __typename?: 'CardEvent';
    actionGroups?: Maybe<Array<Maybe<CardActionGroup>>>;
    actions?: Maybe<Array<Maybe<CardAction>>>;
    icon?: Maybe<Scalars['String']>;
    text?: Maybe<Scalars['String']>;
    ts?: Maybe<Scalars['Int']>;
};

type CardGoalSetsArgs

type CardGoalSetsArgs = {
    goalSetId?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type CardProvenance

type CardProvenance = {
    __typename?: 'CardProvenance';
    name?: Maybe<Scalars['String']>;
};

type CardProvenanceArgs

type CardProvenanceArgs = {
    name?: Maybe<Scalars['String']>;
};

type CardReaction

type CardReaction = {
    __typename?: 'CardReaction';
    avatar?: Maybe<Scalars['String']>;
    login?: Maybe<Scalars['String']>;
    reaction?: Maybe<Scalars['String']>;
};

type CardRepository

type CardRepository = {
    __typename?: 'CardRepository';
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    slug?: Maybe<Scalars['String']>;
};

type CardRepositoryArgs

type CardRepositoryArgs = {
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    slug?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type CardSdmGoal

type CardSdmGoal = {
    __typename?: 'CardSdmGoal';
    actions?: Maybe<Array<Maybe<CardAction>>>;
    description?: Maybe<Scalars['String']>;
    environment?: Maybe<Scalars['String']>;
    link?: Maybe<Scalars['String']>;
    logLink?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    ts?: Maybe<Scalars['Int']>;
};

type CardSdmGoalSet

type CardSdmGoalSet = {
    __typename?: 'CardSdmGoalSet';
    actions?: Maybe<Array<Maybe<CardAction>>>;
    duration?: Maybe<Scalars['Int']>;
    goalSet?: Maybe<Scalars['String']>;
    goalSetId?: Maybe<Scalars['String']>;
    goals?: Maybe<Array<Maybe<CardSdmGoal>>>;
    registration?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    ts?: Maybe<Scalars['Int']>;
};

type CardTitle

type CardTitle = {
    __typename?: 'CardTitle';
    icon?: Maybe<Scalars['String']>;
    text?: Maybe<Scalars['String']>;
};

type ChannelLink

type ChannelLink = {
    __typename?: 'ChannelLink';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** id of  ChannelLink */
    id?: Maybe<Scalars['ID']>;
    /** ChannelLink channel ChatChannel */
    channel?: Maybe<ChatChannel>;
    /** ChannelLink repo Repo */
    repo?: Maybe<Repo>;
};

ChannelLink-Node

type ChannelLinkChannelArgs

type ChannelLinkChannelArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    normalizedName?: Maybe<Scalars['String']>;
    channelId?: Maybe<Scalars['String']>;
    isDefault?: Maybe<Scalars['Boolean']>;
    botInvitedSelf?: Maybe<Scalars['Boolean']>;
    archived?: Maybe<Scalars['Boolean']>;
};

ChannelLink-Node

type ChannelLinked

type ChannelLinked = {
    __typename?: 'ChannelLinked';
    chatTeamId: Scalars['String'];
    id: Scalars['String'];
};

type ChannelLinkListener

type ChannelLinkListener = SdmListener<ChannelLinkListenerInvocation>;

type ChannelLinkRepoArgs

type ChannelLinkRepoArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    allowRebaseMerge?: Maybe<Scalars['Boolean']>;
    allowSquashMerge?: Maybe<Scalars['Boolean']>;
    allowMergeCommit?: Maybe<Scalars['Boolean']>;
    repoId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    defaultBranch?: Maybe<Scalars['String']>;
};

ChannelLink-Node

type ChatChannel

type ChatChannel = {
    __typename?: 'ChatChannel';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** id of  ChatChannel */
    id?: Maybe<Scalars['ID']>;
    /** name of  ChatChannel */
    name?: Maybe<Scalars['String']>;
    /** provider of  ChatChannel */
    provider?: Maybe<Scalars['String']>;
    /** normalizedName of  ChatChannel */
    normalizedName?: Maybe<Scalars['String']>;
    /** channelId of  ChatChannel */
    channelId?: Maybe<Scalars['String']>;
    /** isDefault of  ChatChannel */
    isDefault?: Maybe<Scalars['Boolean']>;
    /** botInvitedSelf of  ChatChannel */
    botInvitedSelf?: Maybe<Scalars['Boolean']>;
    /** archived of  ChatChannel */
    archived?: Maybe<Scalars['Boolean']>;
    /** ChatChannel createdBy ChatId */
    createdBy?: Maybe<ChatId>;
    /** ChatChannel repos Repo */
    repos?: Maybe<Array<Maybe<Repo>>>;
    /** ChatChannel links ChannelLink */
    links?: Maybe<Array<Maybe<ChannelLink>>>;
    /** ChatChannel members ChatId */
    members?: Maybe<Array<Maybe<ChatId>>>;
    /** ChatChannel team ChatTeam */
    team?: Maybe<ChatTeam>;
};

ChatChannel-Node

type ChatChannelCreatedByArgs

type ChatChannelCreatedByArgs = {
    id?: Maybe<Scalars['ID']>;
    screenName?: Maybe<Scalars['String']>;
    userId?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    isAtomistBot?: Maybe<Scalars['String']>;
    isOwner?: Maybe<Scalars['String']>;
    isPrimaryOwner?: Maybe<Scalars['String']>;
    isAdmin?: Maybe<Scalars['String']>;
    isBot?: Maybe<Scalars['String']>;
    timezoneLabel?: Maybe<Scalars['String']>;
};

ChatChannel-Node

type ChatChannelInput

type ChatChannelInput = {
    channelId: Scalars['String'];
    name: Scalars['String'];
    isDefault?: Maybe<Scalars['Boolean']>;
    archived?: Maybe<Scalars['Boolean']>;
};

type ChatChannelLinksArgs

type ChatChannelLinksArgs = {
    orderBy?: Maybe<Array<Maybe<_ChannelLinkOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
};

ChatChannel-Node

type ChatChannelMembersArgs

type ChatChannelMembersArgs = {
    id?: Maybe<Scalars['ID']>;
    screenName?: Maybe<Scalars['String']>;
    userId?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    isAtomistBot?: Maybe<Scalars['String']>;
    isOwner?: Maybe<Scalars['String']>;
    isPrimaryOwner?: Maybe<Scalars['String']>;
    isAdmin?: Maybe<Scalars['String']>;
    isBot?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_ChatIdOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    timezoneLabel?: Maybe<Scalars['String']>;
};

ChatChannel-Node

type ChatChannelReposArgs

type ChatChannelReposArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    allowRebaseMerge?: Maybe<Scalars['Boolean']>;
    allowSquashMerge?: Maybe<Scalars['Boolean']>;
    allowMergeCommit?: Maybe<Scalars['Boolean']>;
    repoId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    defaultBranch?: Maybe<Scalars['String']>;
};

ChatChannel-Node

type ChatChannelTeamArgs

type ChatChannelTeamArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    tenantId?: Maybe<Scalars['String']>;
    domain?: Maybe<Scalars['String']>;
    messageCount?: Maybe<Scalars['Float']>;
    emailDomain?: Maybe<Scalars['String']>;
};

ChatChannel-Node

type ChatId

type ChatId = {
    __typename?: 'ChatId';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** id of  ChatId */
    id?: Maybe<Scalars['ID']>;
    /** screenName of  ChatId */
    screenName?: Maybe<Scalars['String']>;
    /** userId of  ChatId */
    userId?: Maybe<Scalars['String']>;
    /** provider of  ChatId */
    provider?: Maybe<Scalars['String']>;
    /** isAtomistBot of  ChatId */
    isAtomistBot?: Maybe<Scalars['String']>;
    /** isOwner of  ChatId */
    isOwner?: Maybe<Scalars['String']>;
    /** isPrimaryOwner of  ChatId */
    isPrimaryOwner?: Maybe<Scalars['String']>;
    /** isAdmin of  ChatId */
    isAdmin?: Maybe<Scalars['String']>;
    /** isBot of  ChatId */
    isBot?: Maybe<Scalars['String']>;
    /** timezoneLabel of  ChatId */
    timezoneLabel?: Maybe<Scalars['String']>;
    /** ChatId channels ChatChannel */
    channels?: Maybe<Array<Maybe<ChatChannel>>>;
    /** ChatId emails Email */
    emails?: Maybe<Array<Maybe<Email>>>;
    /** ChatId chatTeam ChatTeam */
    chatTeam?: Maybe<ChatTeam>;
    /** ChatId channelsCreated ChatChannel */
    channelsCreated?: Maybe<Array<Maybe<ChatChannel>>>;
    /** ChatId person Person */
    person?: Maybe<Person>;
    /** Return a user's preferences */
    preferences?: Maybe<Array<Maybe<UserPreference>>>;
};

ChatId-Node

type ChatIdChannelsArgs

type ChatIdChannelsArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    normalizedName?: Maybe<Scalars['String']>;
    channelId?: Maybe<Scalars['String']>;
    isDefault?: Maybe<Scalars['Boolean']>;
    botInvitedSelf?: Maybe<Scalars['Boolean']>;
    orderBy?: Maybe<Array<Maybe<_ChatChannelOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    archived?: Maybe<Scalars['Boolean']>;
};

ChatId-Node

type ChatIdChannelsCreatedArgs

type ChatIdChannelsCreatedArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    normalizedName?: Maybe<Scalars['String']>;
    channelId?: Maybe<Scalars['String']>;
    isDefault?: Maybe<Scalars['Boolean']>;
    botInvitedSelf?: Maybe<Scalars['Boolean']>;
    archived?: Maybe<Scalars['Boolean']>;
};

ChatId-Node

type ChatIdChatTeamArgs

type ChatIdChatTeamArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    tenantId?: Maybe<Scalars['String']>;
    domain?: Maybe<Scalars['String']>;
    messageCount?: Maybe<Scalars['Float']>;
    emailDomain?: Maybe<Scalars['String']>;
};

ChatId-Node

type ChatIdEmailsArgs

type ChatIdEmailsArgs = {
    address?: Maybe<Scalars['String']>;
};

ChatId-Node

type ChatIdInput

type ChatIdInput = {
    userId: Scalars['String'];
    screenName: Scalars['String'];
    isAtomistBot?: Maybe<Scalars['Boolean']>;
    isBot?: Maybe<Scalars['Boolean']>;
};

type ChatIdPersonArgs

type ChatIdPersonArgs = {
    id?: Maybe<Scalars['ID']>;
    forename?: Maybe<Scalars['String']>;
    surname?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
};

ChatId-Node

type ChatTeam

type ChatTeam = {
    __typename?: 'ChatTeam';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** id of  ChatTeam */
    id?: Maybe<Scalars['ID']>;
    /** id of the ChatTeam as provided by the ChatTeam, not the atomist identifier of this node */
    chatTeamId: Scalars['String'];
    /** name of  ChatTeam */
    name?: Maybe<Scalars['String']>;
    /** provider of  ChatTeam */
    provider?: Maybe<Scalars['String']>;
    /** This ChatTeams tenantId if available for this provider */
    tenantId?: Maybe<Scalars['String']>;
    /** This is the url for accessing the API on this ChatTeam */
    serviceUrl?: Maybe<Scalars['String']>;
    /** domain of  ChatTeam */
    domain?: Maybe<Scalars['String']>;
    /** messageCount of  ChatTeam */
    messageCount?: Maybe<Scalars['Float']>;
    /** emailDomain of  ChatTeam */
    emailDomain?: Maybe<Scalars['String']>;
    /** Determines whether or not we have finished ingesting the initial set of ChatChannels and ChatIds */
    state?: Maybe<ChatTeamState>;
    /** The number of ChatChannels to be loaded during initialization. */
    initialChatChannelCount?: Maybe<Scalars['Int']>;
    /** The icon for the ChatTeam. May be an external URL. */
    icon?: Maybe<Scalars['String']>;
    /** ISO8601 timestamp updated when this ChatTeam was linked to the Team (workspace) node */
    linkedAt?: Maybe<Scalars['String']>;
    createdAt: Scalars['String'];
    updatedAt: Scalars['String'];
    createdBy?: Maybe<Person>;
    updatedBy?: Maybe<Person>;
    /** ChatTeam orgs Org */
    orgs?: Maybe<Array<Maybe<Org>>>;
    /** ChatTeam channels ChatChannel */
    channels?: Maybe<Array<Maybe<ChatChannel>>>;
    /** ChatTeam members ChatId */
    members?: Maybe<Array<Maybe<ChatId>>>;
    /** ChatTeam team Team */
    team?: Maybe<Team>;
    /** Return a chat team's preferences */
    preferences?: Maybe<Array<Maybe<TeamPreference>>>;
};

ChatTeam-Node

type ChatTeamChannelsArgs

type ChatTeamChannelsArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    normalizedName?: Maybe<Scalars['String']>;
    channelId?: Maybe<Scalars['String']>;
    isDefault?: Maybe<Scalars['Boolean']>;
    botInvitedSelf?: Maybe<Scalars['Boolean']>;
    orderBy?: Maybe<Array<Maybe<_ChatChannelOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    archived?: Maybe<Scalars['Boolean']>;
};

ChatTeam-Node

type ChatTeamMembersArgs

type ChatTeamMembersArgs = {
    id?: Maybe<Scalars['ID']>;
    screenName?: Maybe<Scalars['String']>;
    userId?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    isAtomistBot?: Maybe<Scalars['String']>;
    isOwner?: Maybe<Scalars['String']>;
    isPrimaryOwner?: Maybe<Scalars['String']>;
    isAdmin?: Maybe<Scalars['String']>;
    isBot?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_ChatIdOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    timezoneLabel?: Maybe<Scalars['String']>;
};

ChatTeam-Node

type ChatTeamOrgsArgs

type ChatTeamOrgsArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_OrgOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    ownerType?: Maybe<OwnerType>;
};

ChatTeam-Node

type ChatTeamTeamArgs

type ChatTeamTeamArgs = {
    id?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    iconUrl?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
};

ChatTeam-Node

type CheckRun

type CheckRun = {
    __typename?: 'CheckRun';
    id: Scalars['ID'];
    _id: Scalars['Int'];
    checkRunId: Scalars['String'];
    action: CheckRunAction;
    url: Scalars['String'];
    htmlUrl: Scalars['String'];
    detailsUrl: Scalars['String'];
    conclusion?: Maybe<CheckRunConclusion>;
    startedAt: Scalars['String'];
    completedAt?: Maybe<Scalars['String']>;
    name: Scalars['String'];
    externalId?: Maybe<Scalars['String']>;
    outputTitle?: Maybe<Scalars['String']>;
    outputAnnotationsUrl?: Maybe<Scalars['String']>;
    status: CheckRunStatus;
    requestedActionIdentifier?: Maybe<Scalars['String']>;
    checkSuite: CheckSuite;
};

type CheckSuite

type CheckSuite = {
    __typename?: 'CheckSuite';
    id: Scalars['ID'];
    _id: Scalars['Int'];
    checkSuiteId: Scalars['String'];
    headBranch?: Maybe<Scalars['String']>;
    appSlug: Scalars['String'];
    appId: Scalars['String'];
    url: Scalars['String'];
    checkRunsUrl?: Maybe<Scalars['String']>;
    action?: Maybe<CheckSuiteAction>;
    timestamp: Scalars['String'];
    conclusion?: Maybe<CheckSuiteConclusion>;
    status: CheckSuiteStatus;
    commit?: Maybe<Commit>;
    checkRuns: Array<CheckRun>;
    pullRequests: Array<PullRequest>;
};

type ClosedIssueListener

type ClosedIssueListener = SdmListener<ClosedIssueListenerInvocation>;

type CodeInspection

type CodeInspection<R, P = NoParameters> = (
    p: Project,
    papi: PushAwareParametersInvocation<P>
) => Promise<R>;

Function that can run against a project without mutating it to compute a value.

type CodeTransform

type CodeTransform<P = NoParameters> = (
    p: Project,
    papi: PushAwareParametersInvocation<P>,
    params?: P
) => Promise<TransformReturnable>;

Function that can transform a project. Mixing HandlerContextMethods into second parameter, and third parameter are only for backward compatibility. New code should use (Project, Command ParametersInvocation). Projects are naturally mutable.

type CodeTransformOrTransforms

type CodeTransformOrTransforms<PARAMS> =
    | CodeTransform<PARAMS>
    | Array<CodeTransform<PARAMS>>;

One or many CodeTransforms

type CodeTransformRegistrationDecorator

type CodeTransformRegistrationDecorator<PARAMS> = (
    ctr: CodeTransformRegistration<PARAMS>
) => CodeTransformRegistration<PARAMS>;

Signature of a decorator function that can add additional behavior to a CodeTransformRegistration.

type CommandListener

type CommandListener<PARAMS = NoParameters> = SdmListener<
    CommandListenerInvocation<PARAMS>
>;

type Comment

type Comment = {
    __typename?: 'Comment';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** the url of the Comment */
    url?: Maybe<Scalars['String']>;
    /** id of  Comment */
    id?: Maybe<Scalars['ID']>;
    /** body of  Comment */
    body?: Maybe<Scalars['String']>;
    /** timestamp of  Comment */
    timestamp?: Maybe<Scalars['String']>;
    /** createdAt of  Comment */
    createdAt?: Maybe<Scalars['String']>;
    /** updatedAt of  Comment */
    updatedAt?: Maybe<Scalars['String']>;
    /** commentId of  Comment */
    commentId?: Maybe<Scalars['String']>;
    /** gitHubId of  Comment */
    gitHubId?: Maybe<Scalars['String']>;
    /** path of  Comment */
    path?: Maybe<Scalars['String']>;
    /** position of  Comment */
    position?: Maybe<Scalars['String']>;
    /** htmlUrl of  Comment */
    htmlUrl?: Maybe<Scalars['String']>;
    /** commentType of  Comment */
    commentType?: Maybe<CommentCommentType>;
    /** Comment issue Issue */
    issue?: Maybe<Issue>;
    /** Comment review Review */
    review?: Maybe<Review>;
    /** Comment pullRequest PullRequest */
    pullRequest?: Maybe<PullRequest>;
    /** Comment by SCMId */
    by?: Maybe<ScmId>;
};

Comment-Node

type CommentByArgs

type CommentByArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    avatar?: Maybe<Scalars['String']>;
};

Comment-Node

type CommentIssueArgs

type CommentIssueArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    name?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<IssueState>;
    timestamp?: Maybe<Scalars['String']>;
    action?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    closedAt?: Maybe<Scalars['String']>;
};

Comment-Node

type CommentPullRequestArgs

type CommentPullRequestArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    prId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    merged?: Maybe<Scalars['Boolean']>;
    timestamp?: Maybe<Scalars['String']>;
    baseBranchName?: Maybe<Scalars['String']>;
    branchName?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    closedAt?: Maybe<Scalars['String']>;
    mergedAt?: Maybe<Scalars['String']>;
    mergeStatus?: Maybe<MergeStatus>;
};

Comment-Node

type CommentReviewArgs

type CommentReviewArgs = {
    id?: Maybe<Scalars['ID']>;
    gitHubId?: Maybe<Scalars['String']>;
    reviewId?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<ReviewState>;
    submittedAt?: Maybe<Scalars['String']>;
    htmlUrl?: Maybe<Scalars['String']>;
};

Comment-Node

type Commit

type Commit = {
    __typename?: 'Commit';
    id?: Maybe<Scalars['ID']>;
    _id?: Maybe<Scalars['Int']>;
    url?: Maybe<Scalars['String']>;
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    email?: Maybe<Email>;
    checkSuites?: Maybe<Array<Maybe<CheckSuite>>>;
    /** Commit builds Build */
    builds?: Maybe<Array<Maybe<Build>>>;
    /** Pipelines associated with this commit if applicable */
    pipelines?: Maybe<Array<Maybe<Pipeline>>>;
    /** Commit repo Repo */
    repo?: Maybe<Repo>;
    /** Commit author SCMId */
    author?: Maybe<ScmId>;
    /** Commit committer SCMId */
    committer?: Maybe<ScmId>;
    /** Commit tags Tag */
    tags?: Maybe<Array<Maybe<Tag>>>;
    /** Commit resolves Issue */
    resolves?: Maybe<Array<Maybe<Issue>>>;
    /** Commit statuses Status */
    statuses?: Maybe<Array<Maybe<Status>>>;
    /** Commit pushes Push */
    pushes?: Maybe<Array<Maybe<Push>>>;
    /** Commit pullRequests PullRequest */
    pullRequests?: Maybe<Array<Maybe<PullRequest>>>;
    /** Commit herokuApps HerokuApp */
    herokuApps?: Maybe<Array<Maybe<HerokuApp>>>;
    /** Commit apps Application */
    apps?: Maybe<Array<Maybe<Application>>>;
    /** Commit image DockerImage */
    image?: Maybe<DockerImage>;
    /** Commit images DockerImage */
    images?: Maybe<Array<Maybe<DockerImage>>>;
    dockerRegistryImages?: Maybe<Array<Maybe<DockerRegistryImage>>>;
    analysis: Array<SourceFingerprint>;
};

Commit-Node

type CommitAnalysisArgs

type CommitAnalysisArgs = {
    name?: Maybe<Scalars['String']>;
    type?: Maybe<Scalars['String']>;
};

Commit-Node

type CommitAppsArgs

type CommitAppsArgs = {
    id?: Maybe<Scalars['ID']>;
    state?: Maybe<Scalars['String']>;
    host?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    domain?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_ApplicationOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    data?: Maybe<Scalars['String']>;
};

Commit-Node

type CommitAuthorArgs

type CommitAuthorArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    avatar?: Maybe<Scalars['String']>;
};

Commit-Node

type CommitBuildsArgs

type CommitBuildsArgs = {
    id?: Maybe<Scalars['ID']>;
    buildId?: Maybe<Scalars['String']>;
    number?: Maybe<Scalars['Int']>;
    name?: Maybe<Scalars['String']>;
    status?: Maybe<BuildStatus>;
    buildUrl?: Maybe<Scalars['String']>;
    compareUrl?: Maybe<Scalars['String']>;
    trigger?: Maybe<BuildTrigger>;
    provider?: Maybe<Scalars['String']>;
    pullRequestNumber?: Maybe<Scalars['Float']>;
    startedAt?: Maybe<Scalars['String']>;
    finishedAt?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    workflowId?: Maybe<Scalars['String']>;
    jobName?: Maybe<Scalars['String']>;
    jobId?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_BuildOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    data?: Maybe<Scalars['String']>;
};

Commit-Node

type CommitCheckSuitesArgs

type CommitCheckSuitesArgs = {
    appSlug?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_CheckSuiteOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    appId?: Maybe<Scalars['String']>;
};

Commit-Node

type CommitCommitterArgs

type CommitCommitterArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    avatar?: Maybe<Scalars['String']>;
};

Commit-Node

type CommitEmailArgs

type CommitEmailArgs = {
    address?: Maybe<Scalars['String']>;
};

Commit-Node

type CommitFingerprintImpact

type CommitFingerprintImpact = {
    __typename?: 'CommitFingerprintImpact';
    diffs: Array<FingerprintDiff>;
    id: Scalars['ID'];
    offTarget: Array<SourceFingerprint>;
    branch?: Maybe<Branch>;
    commit?: Maybe<Commit>;
    previousCommit?: Maybe<Commit>;
    repo?: Maybe<Repo>;
};

type CommitForSdmGoalQuery

type CommitForSdmGoalQuery = {
    __typename?: 'Query';
} & {
    Commit?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Commit';
                } & Pick<Commit, 'sha' | 'message'> & {
                        statuses?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'Status';
                                    } & Pick<
                                        Status,
                                        | 'context'
                                        | 'description'
                                        | 'state'
                                        | 'targetUrl'
                                    >
                                >
                            >
                        >;
                        repo?: Maybe<
                            {
                                __typename?: 'Repo';
                            } & CoreRepoFieldsAndChannelsFragment
                        >;
                        pushes?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'Push';
                                    } & PushFieldsFragment
                                >
                            >
                        >;
                        image?: Maybe<
                            {
                                __typename?: 'DockerImage';
                            } & Pick<DockerImage, 'image' | 'imageName'>
                        >;
                        images?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'DockerImage';
                                    } & Pick<DockerImage, 'image' | 'imageName'>
                                >
                            >
                        >;
                    }
            >
        >
    >;
};

type CommitForSdmGoalQueryVariables

type CommitForSdmGoalQueryVariables = {
    sha: Scalars['String'];
    repo: Scalars['String'];
    owner: Scalars['String'];
    branch: Scalars['String'];
};

type CommitHerokuAppsArgs

type CommitHerokuAppsArgs = {
    app?: Maybe<Scalars['String']>;
    url?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    user?: Maybe<Scalars['String']>;
    appId?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_HerokuAppOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    release?: Maybe<Scalars['String']>;
};

Commit-Node

type CommitImageArgs

type CommitImageArgs = {
    image?: Maybe<Scalars['String']>;
    imageName?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

Commit-Node

type CommitImagesArgs

type CommitImagesArgs = {
    image?: Maybe<Scalars['String']>;
    imageName?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_DockerImageOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    timestamp?: Maybe<Scalars['String']>;
};

Commit-Node

type CommitIssueRelationship

type CommitIssueRelationship = {
    __typename?: 'CommitIssueRelationship';
    commit?: Maybe<CommitIssueRelationshipCommit>;
    issue?: Maybe<CommitIssueRelationshipIssue>;
    type?: Maybe<CommitIssueRelationshipType>;
    /** The ID of this CommitIssueRelationship */
    id?: Maybe<Scalars['ID']>;
};

type CommitIssueRelationshipCommit

type CommitIssueRelationshipCommit = {
    __typename?: 'CommitIssueRelationshipCommit';
    owner?: Maybe<Scalars['String']>;
    repo?: Maybe<Scalars['String']>;
    sha?: Maybe<Scalars['String']>;
};

type CommitIssueRelationshipCommitArgs

type CommitIssueRelationshipCommitArgs = {
    sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    repo?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type CommitIssueRelationshipIssue

type CommitIssueRelationshipIssue = {
    __typename?: 'CommitIssueRelationshipIssue';
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    repo?: Maybe<Scalars['String']>;
};

type CommitIssueRelationshipIssueArgs

type CommitIssueRelationshipIssueArgs = {
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    repo?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type CommitLink

type CommitLink = {
    sha: Scalars['String'];
};

type CommitPipelinesArgs

type CommitPipelinesArgs = {
    pipelineId?: Maybe<Scalars['ID']>;
};

Commit-Node

type CommitPullRequestsArgs

type CommitPullRequestsArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    prId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    merged?: Maybe<Scalars['Boolean']>;
    timestamp?: Maybe<Scalars['String']>;
    baseBranchName?: Maybe<Scalars['String']>;
    branchName?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    closedAt?: Maybe<Scalars['String']>;
    mergedAt?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_PullRequestOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    mergeStatus?: Maybe<MergeStatus>;
};

Commit-Node

type CommitPushesArgs

type CommitPushesArgs = {
    id?: Maybe<Scalars['ID']>;
    timestamp?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_PushOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    branch?: Maybe<Scalars['String']>;
};

Commit-Node

type CommitRepoArgs

type CommitRepoArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    allowRebaseMerge?: Maybe<Scalars['Boolean']>;
    allowSquashMerge?: Maybe<Scalars['Boolean']>;
    allowMergeCommit?: Maybe<Scalars['Boolean']>;
    repoId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    defaultBranch?: Maybe<Scalars['String']>;
};

Commit-Node

type CommitResolvesArgs

type CommitResolvesArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    name?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<IssueState>;
    timestamp?: Maybe<Scalars['String']>;
    action?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_IssueOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    closedAt?: Maybe<Scalars['String']>;
};

Commit-Node

type CommitStatusesArgs

type CommitStatusesArgs = {
    id?: Maybe<Scalars['ID']>;
    state?: Maybe<StatusState>;
    description?: Maybe<Scalars['String']>;
    targetUrl?: Maybe<Scalars['String']>;
    context?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_StatusOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    timestamp?: Maybe<Scalars['String']>;
};

Commit-Node

type CommitsWithFingerprints

type CommitsWithFingerprints = {
    __typename?: 'CommitsWithFingerprints';
    _paging?: Maybe<PagingInfo>;
    commits: Array<FingerprintedCommit>;
};

type CommitTagsArgs

type CommitTagsArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    ref?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_TagOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    timestamp?: Maybe<Scalars['String']>;
};

Commit-Node

type ConfiguredAtomistSkill

type ConfiguredAtomistSkill = AtomistSkill & {
    __typename?: 'ConfiguredAtomistSkill';
    artifacts: Array<AtomistSkillArtifact>;
    author: Scalars['String'];
    capabilities: AtomistSkillCapabilitiesSpec;
    categories: Array<AtomistSkillCategory>;
    commands: Array<AtomistChatCommand>;
    configuration?: Maybe<AtomistSkillConfiguration>;
    createdAt: Scalars['String'];
    datalogSubscriptions?: Maybe<Array<AtomistSkillDatalogSubscription>>;
    description: Scalars['String'];
    dispatchStyle: AtomistSkillEventDispatchStyle;
    displayName?: Maybe<Scalars['String']>;
    executions: Array<AtomistSkillExecution>;
    homepageUrl: Scalars['String'];
    iconUrl: Scalars['String'];
    id: Scalars['String'];
    inCatalog: Scalars['Boolean'];
    ingesters: Array<Scalars['String']>;
    integration: Scalars['Boolean'];
    license: Scalars['String'];
    longDescription: Scalars['String'];
    maturities: Array<AtomistSkillMaturityLevel>;
    maxConfigurations: Scalars['Int'];
    name: Scalars['String'];
    namespace: Scalars['String'];
    owner: Scalars['Boolean'];
    parameters: Array<AtomistSkillParameterSpec>;
    platform: AtomistSkillExecutionPlatform;
    publishedAt?: Maybe<Scalars['String']>;
    readme?: Maybe<Scalars['String']>;
    resourceProviders?: Maybe<Array<AtomistSkillResourceProviderSpec>>;
    schemata?: Maybe<Array<AtomistSkillIngestionSchema>>;
    status: AtomistSkillStatus;
    subscriptions: Array<Scalars['String']>;
    technologies: Array<AtomistSkillTechnology>;
    version: Scalars['String'];
    videoUrl?: Maybe<Scalars['String']>;
};

type ConfiguredAtomistSkillConfigurationArgs

type ConfiguredAtomistSkillConfigurationArgs = {
    commitSha?: Maybe<Scalars['String']>;
    includeDefaults?: Maybe<Scalars['Boolean']>;
    names?: Maybe<Array<Scalars['String']>>;
    visibility?: Maybe<Array<AtomistSkillParameterVisiblity>>;
};

type ConfigureMachine

type ConfigureMachine = (sdm: SoftwareDeliveryMachine) => void;

Configure the given SDM

type CoreCommitFieldsFragment

type CoreCommitFieldsFragment = {
    __typename?: 'Commit';
} & Pick<Commit, 'url' | 'sha' | 'message' | 'timestamp'> & {
        committer?: Maybe<
            {
                __typename?: 'SCMId';
            } & {
                person?: Maybe<
                    {
                        __typename?: 'Person';
                    } & PersonFieldsFragment
                >;
            }
        >;
    };

type CoreRepoFieldsAndChannelsFragment

type CoreRepoFieldsAndChannelsFragment = {
    __typename?: 'Repo';
} & Pick<Repo, 'id' | 'url' | 'owner' | 'name' | 'defaultBranch'> & {
        org?: Maybe<
            {
                __typename?: 'Org';
            } & Pick<Org, 'id' | 'owner' | 'ownerType'> & {
                    provider?: Maybe<
                        {
                            __typename?: 'GitHubProvider';
                        } & Pick<
                            GitHubProvider,
                            'providerId' | 'providerType' | 'apiUrl' | 'url'
                        >
                    >;
                }
        >;
        channels?: Maybe<
            Array<
                Maybe<
                    {
                        __typename?: 'ChatChannel';
                    } & Pick<ChatChannel, 'name' | 'id' | 'channelId'> & {
                            team?: Maybe<
                                {
                                    __typename?: 'ChatTeam';
                                } & Pick<ChatTeam, 'id'>
                            >;
                        }
                >
            >
        >;
    };

type CorrelationBody

type CorrelationBody = {
    __typename?: 'CorrelationBody';
    icon?: Maybe<Scalars['String']>;
    text?: Maybe<Scalars['String']>;
};

type CreateJobMutation

type CreateJobMutation = {
    __typename?: 'Mutation';
} & {
    createAtmJob?: Maybe<
        {
            __typename?: 'AtmJob';
        } & Pick<AtmJob, 'id'>
    >;
};

type CreateJobMutationVariables

type CreateJobMutationVariables = {
    data: Scalars['String'];
    name: Scalars['String'];
    description: Scalars['String'];
    owner: Scalars['String'];
    concurrentTasks?: Maybe<Scalars['Int']>;
    tasks: Array<AtmJobTaskInput>;
};

type Credential

type Credential = {
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    _id: Scalars['Int'];
    id: Scalars['ID'];
    owner: ResourceUser;
};

type CredentialInput

type CredentialInput = {
    type: CredentialType;
    oauth?: Maybe<OAuthInput>;
    password?: Maybe<PasswordInput>;
};

type CustomApplyPolicyLogInput

type CustomApplyPolicyLogInput = {
    _prId?: Maybe<Scalars['ID']>;
    _sha?: Maybe<Scalars['String']>;
    branch?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    state?: Maybe<ApplyPolicyState>;
    targetSha?: Maybe<Scalars['String']>;
};

Auto generated input for type ApplyPolicyLog

type CustomAspectRegistrationInput

type CustomAspectRegistrationInput = {
    category?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    endpoint?: Maybe<Scalars['String']>;
    manageable?: Maybe<Scalars['Boolean']>;
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    shortName?: Maybe<Scalars['String']>;
    state?: Maybe<AspectRegistrationState>;
    unit?: Maybe<Scalars['String']>;
    url?: Maybe<Scalars['String']>;
    uuid?: Maybe<Scalars['String']>;
};

Auto generated input for type AspectRegistration

type CustomCardActionConfirmationInput

type CustomCardActionConfirmationInput = {
    body?: Maybe<Scalars['String']>;
    dismiss?: Maybe<Scalars['String']>;
    ok?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
};

Auto generated input for type CardActionConfirmation

type CustomCardActionGroupInput

type CustomCardActionGroupInput = {
    actions?: Maybe<Array<Maybe<CustomCardActionInput>>>;
    text?: Maybe<Scalars['String']>;
};

Auto generated input for type CardActionGroup

type CustomCardActionInput

type CustomCardActionInput = {
    command?: Maybe<Scalars['String']>;
    confirm?: Maybe<CustomCardActionConfirmationInput>;
    parameterName?: Maybe<Scalars['String']>;
    parameterOptionGroups?: Maybe<
        Array<Maybe<CustomCardActionParameterOptionGroupInput>>
    >;
    parameterOptions?: Maybe<Array<Maybe<CustomCardActionParameterOptionInput>>>;
    parameters?: Maybe<Array<Maybe<CustomCardActionParameterInput>>>;
    registration?: Maybe<Scalars['String']>;
    role?: Maybe<Scalars['String']>;
    text?: Maybe<Scalars['String']>;
    type?: Maybe<Scalars['String']>;
};

Auto generated input for type CardAction

type CustomCardActionParameterInput

type CustomCardActionParameterInput = {
    name?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
};

Auto generated input for type CardActionParameter

type CustomCardActionParameterOptionGroupInput

type CustomCardActionParameterOptionGroupInput = {
    name?: Maybe<Scalars['String']>;
    options?: Maybe<Array<Maybe<CustomCardActionParameterOptionInput>>>;
};

Auto generated input for type CardActionParameterOptionGroup

type CustomCardActionParameterOptionInput

type CustomCardActionParameterOptionInput = {
    name?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
};

Auto generated input for type CardActionParameterOption

type CustomCardBodyInput

type CustomCardBodyInput = {
    avatar?: Maybe<Scalars['String']>;
    hint?: Maybe<Scalars['String']>;
    login?: Maybe<Scalars['String']>;
    text?: Maybe<Scalars['String']>;
    ts?: Maybe<Scalars['Int']>;
};

Auto generated input for type CardBody

type CustomCardCollaboratorInput

type CustomCardCollaboratorInput = {
    avatar?: Maybe<Scalars['String']>;
    link?: Maybe<Scalars['String']>;
    login?: Maybe<Scalars['String']>;
};

Auto generated input for type CardCollaborator

type CustomCardCorrelationInput

type CustomCardCorrelationInput = {
    body?: Maybe<Array<Maybe<CustomCorrelationBodyInput>>>;
    icon?: Maybe<Scalars['String']>;
    link?: Maybe<Scalars['String']>;
    shortTitle?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    ts?: Maybe<Scalars['Int']>;
    type?: Maybe<Scalars['String']>;
};

Auto generated input for type CardCorrelation

type CustomCardEventInput

type CustomCardEventInput = {
    actionGroups?: Maybe<Array<Maybe<CustomCardActionGroupInput>>>;
    actions?: Maybe<Array<Maybe<CustomCardActionInput>>>;
    icon?: Maybe<Scalars['String']>;
    text?: Maybe<Scalars['String']>;
    ts?: Maybe<Scalars['Int']>;
};

Auto generated input for type CardEvent

type CustomCardInput

type CustomCardInput = {
    actionGroups?: Maybe<Array<Maybe<CustomCardActionGroupInput>>>;
    actions?: Maybe<Array<Maybe<CustomCardActionInput>>>;
    body?: Maybe<CustomCardBodyInput>;
    collaborators?: Maybe<Array<Maybe<CustomCardCollaboratorInput>>>;
    comments?: Maybe<Array<Maybe<CustomCardBodyInput>>>;
    correlations?: Maybe<Array<Maybe<CustomCardCorrelationInput>>>;
    events?: Maybe<Array<Maybe<CustomCardEventInput>>>;
    goalSets?: Maybe<Array<Maybe<CustomCardSdmGoalSetInput>>>;
    key?: Maybe<Scalars['String']>;
    post?: Maybe<Scalars['String']>;
    provenance?: Maybe<Array<Maybe<CustomCardProvenanceInput>>>;
    reactions?: Maybe<Array<Maybe<CustomCardReactionInput>>>;
    repository?: Maybe<CustomCardRepositoryInput>;
    shortTitle?: Maybe<Scalars['String']>;
    title?: Maybe<CustomCardTitleInput>;
    ts?: Maybe<Scalars['Int']>;
    ttl?: Maybe<Scalars['Int']>;
    type?: Maybe<Scalars['String']>;
};

Auto generated input for type Card

type CustomCardProvenanceInput

type CustomCardProvenanceInput = {
    name?: Maybe<Scalars['String']>;
};

Auto generated input for type CardProvenance

type CustomCardReactionInput

type CustomCardReactionInput = {
    avatar?: Maybe<Scalars['String']>;
    login?: Maybe<Scalars['String']>;
    reaction?: Maybe<Scalars['String']>;
};

Auto generated input for type CardReaction

type CustomCardRepositoryInput

type CustomCardRepositoryInput = {
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    slug?: Maybe<Scalars['String']>;
};

Auto generated input for type CardRepository

type CustomCardSdmGoalInput

type CustomCardSdmGoalInput = {
    actions?: Maybe<Array<Maybe<CustomCardActionInput>>>;
    description?: Maybe<Scalars['String']>;
    environment?: Maybe<Scalars['String']>;
    link?: Maybe<Scalars['String']>;
    logLink?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    ts?: Maybe<Scalars['Int']>;
};

Auto generated input for type CardSdmGoal

type CustomCardSdmGoalSetInput

type CustomCardSdmGoalSetInput = {
    actions?: Maybe<Array<Maybe<CustomCardActionInput>>>;
    duration?: Maybe<Scalars['Int']>;
    goalSet?: Maybe<Scalars['String']>;
    goalSetId?: Maybe<Scalars['String']>;
    goals?: Maybe<Array<Maybe<CustomCardSdmGoalInput>>>;
    registration?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    ts?: Maybe<Scalars['Int']>;
};

Auto generated input for type CardSdmGoalSet

type CustomCardTitleInput

type CustomCardTitleInput = {
    icon?: Maybe<Scalars['String']>;
    text?: Maybe<Scalars['String']>;
};

Auto generated input for type CardTitle

type CustomCommitIssueRelationshipCommitInput

type CustomCommitIssueRelationshipCommitInput = {
    owner?: Maybe<Scalars['String']>;
    repo?: Maybe<Scalars['String']>;
    sha?: Maybe<Scalars['String']>;
};

Auto generated input for type CommitIssueRelationshipCommit

type CustomCommitIssueRelationshipInput

type CustomCommitIssueRelationshipInput = {
    commit?: Maybe<CustomCommitIssueRelationshipCommitInput>;
    issue?: Maybe<CustomCommitIssueRelationshipIssueInput>;
    type?: Maybe<CommitIssueRelationshipType>;
};

Auto generated input for type CommitIssueRelationship

type CustomCommitIssueRelationshipIssueInput

type CustomCommitIssueRelationshipIssueInput = {
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    repo?: Maybe<Scalars['String']>;
};

Auto generated input for type CommitIssueRelationshipIssue

type CustomCorrelationBodyInput

type CustomCorrelationBodyInput = {
    icon?: Maybe<Scalars['String']>;
    text?: Maybe<Scalars['String']>;
};

Auto generated input for type CorrelationBody

type CustomDeploymentCommitInput

type CustomDeploymentCommitInput = {
    owner?: Maybe<Scalars['String']>;
    repo?: Maybe<Scalars['String']>;
    sha?: Maybe<Scalars['String']>;
};

Auto generated input for type DeploymentCommit

type CustomDeploymentInput

type CustomDeploymentInput = {
    commit?: Maybe<CustomDeploymentCommitInput>;
    environment?: Maybe<Scalars['String']>;
    ts?: Maybe<Scalars['Int']>;
};

Auto generated input for type Deployment

type CustomIssueRelationshipInput

type CustomIssueRelationshipInput = {
    relationshipId?: Maybe<Scalars['String']>;
    source?: Maybe<CustomIssueRelationshipIssueInput>;
    state?: Maybe<Scalars['String']>;
    target?: Maybe<CustomIssueRelationshipIssueInput>;
    type?: Maybe<Scalars['String']>;
};

Auto generated input for type IssueRelationship

type CustomIssueRelationshipIssueInput

type CustomIssueRelationshipIssueInput = {
    issue?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    repo?: Maybe<Scalars['String']>;
};

Auto generated input for type IssueRelationshipIssue

type CustomLifecycleAttachmentInput

type CustomLifecycleAttachmentInput = {
    body?: Maybe<Scalars['String']>;
    configuration?: Maybe<Scalars['String']>;
    contentType?: Maybe<Scalars['String']>;
    identifier?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    skill?: Maybe<Scalars['String']>;
    ts?: Maybe<Scalars['Int']>;
    type?: Maybe<LifecycleAttachmentType>;
};

Auto generated input for type LifecycleAttachment

type CustomManageSubscriptionPolicyLogInput

type CustomManageSubscriptionPolicyLogInput = {
    action?: Maybe<ManageSubscriptionPolicyAction>;
    author?: Maybe<Scalars['String']>;
    branch?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    reason?: Maybe<Scalars['String']>;
    repo?: Maybe<Scalars['String']>;
    streamId?: Maybe<Scalars['ID']>;
    streamName?: Maybe<Scalars['String']>;
    targetSha?: Maybe<Scalars['String']>;
    targetValue?: Maybe<Scalars['String']>;
};

Auto generated input for type ManageSubscriptionPolicyLog

type CustomManageTargetPolicyLogInput

type CustomManageTargetPolicyLogInput = {
    action?: Maybe<ManageTargetPolicyAction>;
    author?: Maybe<Scalars['String']>;
    reason?: Maybe<Scalars['String']>;
    streamId?: Maybe<Scalars['ID']>;
    streamName?: Maybe<Scalars['String']>;
    targetSha?: Maybe<Scalars['String']>;
    targetValue?: Maybe<Scalars['String']>;
};

Auto generated input for type ManageTargetPolicyLog

type CustomNotificationActionGroupInput

type CustomNotificationActionGroupInput = {
    actions?: Maybe<Array<Maybe<CustomCardActionInput>>>;
    text?: Maybe<Scalars['String']>;
};

Auto generated input for type NotificationActionGroup

type CustomNotificationActionInput

type CustomNotificationActionInput = {
    command?: Maybe<Scalars['String']>;
    parameterName?: Maybe<Scalars['String']>;
    parameterOptionGroups?: Maybe<
        Array<Maybe<CustomNotificationActionParameterOptionGroupInput>>
    >;
    parameterOptions?: Maybe<
        Array<Maybe<CustomNotificationActionParameterOptionInput>>
    >;
    parameters?: Maybe<Array<Maybe<CustomNotificationActionParameterInput>>>;
    registration?: Maybe<Scalars['String']>;
    role?: Maybe<Scalars['String']>;
    text?: Maybe<Scalars['String']>;
    type?: Maybe<Scalars['String']>;
};

Auto generated input for type NotificationAction

type CustomNotificationActionParameterInput

type CustomNotificationActionParameterInput = {
    name?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
};

Auto generated input for type NotificationActionParameter

type CustomNotificationActionParameterOptionGroupInput

type CustomNotificationActionParameterOptionGroupInput = {
    name?: Maybe<Scalars['String']>;
    options?: Maybe<Array<Maybe<CustomNotificationActionParameterOptionInput>>>;
};

Auto generated input for type NotificationActionParameterOptionGroup

type CustomNotificationActionParameterOptionInput

type CustomNotificationActionParameterOptionInput = {
    name?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
};

Auto generated input for type NotificationActionParameterOption

type CustomNotificationInput

type CustomNotificationInput = {
    actions?: Maybe<Array<Maybe<CustomNotificationActionInput>>>;
    body: Scalars['String'];
    contentType: Scalars['String'];
    correlationId: Scalars['String'];
    key: Scalars['String'];
    post?: Maybe<Scalars['String']>;
    recipient?: Maybe<CustomNotificationRecipientInput>;
    ts: Scalars['Int'];
    ttl?: Maybe<Scalars['Int']>;
};

Auto generated input for type Notification

type CustomNotificationRecipientInput

type CustomNotificationRecipientInput = {
    address: Scalars['String'];
};

Auto generated input for type NotificationRecipient

type CustomPolicyComplianceAspectInput

type CustomPolicyComplianceAspectInput = {
    displayType?: Maybe<Scalars['String']>;
    manageable?: Maybe<Scalars['Boolean']>;
    type?: Maybe<Scalars['String']>;
};

Auto generated input for type PolicyComplianceAspect

type CustomPolicyComplianceFingerprintInput

type CustomPolicyComplianceFingerprintInput = {
    data?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    displayType?: Maybe<Scalars['String']>;
    displayValue?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    sha?: Maybe<Scalars['String']>;
    type?: Maybe<Scalars['String']>;
};

Auto generated input for type PolicyComplianceFingerprint

type CustomPolicyComplianceInput

type CustomPolicyComplianceInput = {
    _branch?: Maybe<Scalars['String']>;
    _owner?: Maybe<Scalars['String']>;
    _repo?: Maybe<Scalars['String']>;
    _sha?: Maybe<Scalars['String']>;
    aspects?: Maybe<Array<Maybe<CustomPolicyComplianceAspectInput>>>;
    differences?: Maybe<Array<Maybe<CustomPolicyComplianceFingerprintInput>>>;
    owner?: Maybe<Scalars['String']>;
    state?: Maybe<PolicyCompliaceState>;
    targets?: Maybe<Array<Maybe<CustomPolicyComplianceFingerprintInput>>>;
    ts?: Maybe<Scalars['Int']>;
};

Auto generated input for type PolicyCompliance

type CustomPolicyLogInput

type CustomPolicyLogInput = {
    apply?: Maybe<CustomApplyPolicyLogInput>;
    manage?: Maybe<CustomManageTargetPolicyLogInput>;
    name?: Maybe<Scalars['String']>;
    subscribe?: Maybe<CustomManageSubscriptionPolicyLogInput>;
    ts?: Maybe<Scalars['Int']>;
    type?: Maybe<Scalars['String']>;
};

Auto generated input for type PolicyLog

type CustomPolicyTargetInput

type CustomPolicyTargetInput = {
    data?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    displayValue?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    sha?: Maybe<Scalars['String']>;
    streams?: Maybe<Array<Maybe<Scalars['ID']>>>;
    type?: Maybe<Scalars['String']>;
};

Auto generated input for type PolicyTarget

type CustomPolicyTargetStreamInput

type CustomPolicyTargetStreamInput = {
    name?: Maybe<Scalars['String']>;
};

Auto generated input for type PolicyTargetStream

type CustomSdmBuildIdentifierInput

type CustomSdmBuildIdentifierInput = {
    identifier?: Maybe<Scalars['String']>;
    repo?: Maybe<CustomSdmBuildIdentifierRepositoryInput>;
};

Auto generated input for type SdmBuildIdentifier

type CustomSdmBuildIdentifierRepositoryInput

type CustomSdmBuildIdentifierRepositoryInput = {
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
};

Auto generated input for type SdmBuildIdentifierRepository

type CustomSdmConditionInput

type CustomSdmConditionInput = {
    environment?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    uniqueName?: Maybe<Scalars['String']>;
};

Auto generated input for type SdmCondition

type CustomSdmDeployEnablementInput

type CustomSdmDeployEnablementInput = {
    owner?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
    repo?: Maybe<Scalars['String']>;
    state?: Maybe<SdmDeployState>;
};

Auto generated input for type SdmDeployEnablement

type CustomSdmExternalUrlInput

type CustomSdmExternalUrlInput = {
    label?: Maybe<Scalars['String']>;
    url?: Maybe<Scalars['String']>;
};

Auto generated input for type SdmExternalUrl

type CustomSdmGoalDescriptionsInput

type CustomSdmGoalDescriptionsInput = {
    canceled?: Maybe<Scalars['String']>;
    completed?: Maybe<Scalars['String']>;
    failed?: Maybe<Scalars['String']>;
    inProcess?: Maybe<Scalars['String']>;
    planned?: Maybe<Scalars['String']>;
    requested?: Maybe<Scalars['String']>;
    skipped?: Maybe<Scalars['String']>;
    stopped?: Maybe<Scalars['String']>;
    waitingForApproval?: Maybe<Scalars['String']>;
    waitingForPreApproval?: Maybe<Scalars['String']>;
};

Auto generated input for type SdmGoalDescriptions

type CustomSdmGoalDisplayInput

type CustomSdmGoalDisplayInput = {
    branch?: Maybe<Scalars['String']>;
    format?: Maybe<SdmGoalDisplayFormat>;
    repo?: Maybe<CustomSdmRepositoryInput>;
    sha?: Maybe<Scalars['String']>;
    state?: Maybe<SdmGoalDisplayState>;
    ts?: Maybe<Scalars['Int']>;
};

Auto generated input for type SdmGoalDisplay

type CustomSdmGoalFulfillmentInput

type CustomSdmGoalFulfillmentInput = {
    method?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    registration?: Maybe<Scalars['String']>;
};

Auto generated input for type SdmGoalFulfillment

type CustomSdmGoalInput

type CustomSdmGoalInput = {
    approval?: Maybe<CustomSdmProvenanceInput>;
    approvalRequired?: Maybe<Scalars['Boolean']>;
    branch?: Maybe<Scalars['String']>;
    data?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    descriptions?: Maybe<CustomSdmGoalDescriptionsInput>;
    environment?: Maybe<Scalars['String']>;
    error?: Maybe<Scalars['String']>;
    externalKey?: Maybe<Scalars['String']>;
    externalUrl?: Maybe<Scalars['String']>;
    externalUrls?: Maybe<Array<Maybe<CustomSdmExternalUrlInput>>>;
    fulfillment?: Maybe<CustomSdmGoalFulfillmentInput>;
    goalSet?: Maybe<Scalars['String']>;
    goalSetId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    parameters?: Maybe<Scalars['String']>;
    phase?: Maybe<Scalars['String']>;
    preApproval?: Maybe<CustomSdmProvenanceInput>;
    preApprovalRequired?: Maybe<Scalars['Boolean']>;
    preConditions?: Maybe<Array<Maybe<CustomSdmConditionInput>>>;
    provenance?: Maybe<Array<Maybe<CustomSdmProvenanceInput>>>;
    registration?: Maybe<Scalars['String']>;
    repo?: Maybe<CustomSdmRepositoryInput>;
    retryFeasible?: Maybe<Scalars['Boolean']>;
    sha?: Maybe<Scalars['String']>;
    signature?: Maybe<Scalars['String']>;
    state?: Maybe<SdmGoalState>;
    ts?: Maybe<Scalars['Int']>;
    uniqueName?: Maybe<Scalars['String']>;
    url?: Maybe<Scalars['String']>;
    version?: Maybe<Scalars['Int']>;
};

Auto generated input for type SdmGoal

type CustomSdmGoalNameInput

type CustomSdmGoalNameInput = {
    name?: Maybe<Scalars['String']>;
    uniqueName?: Maybe<Scalars['String']>;
};

Auto generated input for type SdmGoalName

type CustomSdmGoalSetBadgeInput

type CustomSdmGoalSetBadgeInput = {
    repo?: Maybe<CustomSdmGoalSetBadgeRepositoryInput>;
    sdm?: Maybe<Scalars['String']>;
    token?: Maybe<Scalars['String']>;
};

Auto generated input for type SdmGoalSetBadge

type CustomSdmGoalSetBadgeRepositoryInput

type CustomSdmGoalSetBadgeRepositoryInput = {
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
};

Auto generated input for type SdmGoalSetBadgeRepository

type CustomSdmGoalSetInput

type CustomSdmGoalSetInput = {
    branch?: Maybe<Scalars['String']>;
    goalSet?: Maybe<Scalars['String']>;
    goalSetId?: Maybe<Scalars['String']>;
    goals?: Maybe<Array<Maybe<CustomSdmGoalNameInput>>>;
    provenance?: Maybe<CustomSdmProvenanceInput>;
    repo?: Maybe<CustomSdmRepositoryInput>;
    sha?: Maybe<Scalars['String']>;
    state?: Maybe<SdmGoalState>;
    tags?: Maybe<Array<Maybe<CustomSdmGoalSetTagInput>>>;
    ts?: Maybe<Scalars['Int']>;
};

Auto generated input for type SdmGoalSet

type CustomSdmGoalSetTagInput

type CustomSdmGoalSetTagInput = {
    name?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
};

Auto generated input for type SdmGoalSetTag

type CustomSdmPreferenceInput

type CustomSdmPreferenceInput = {
    key?: Maybe<Scalars['String']>;
    ttl?: Maybe<Scalars['Int']>;
    value?: Maybe<Scalars['String']>;
};

Auto generated input for type SdmPreference

type CustomSdmProvenanceInput

type CustomSdmProvenanceInput = {
    channelId?: Maybe<Scalars['String']>;
    correlationId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    registration?: Maybe<Scalars['String']>;
    ts?: Maybe<Scalars['Int']>;
    userId?: Maybe<Scalars['String']>;
    version?: Maybe<Scalars['String']>;
};

Auto generated input for type SdmProvenance

type CustomSdmRepoProvenanceInput

type CustomSdmRepoProvenanceInput = {
    provenance?: Maybe<CustomSdmProvenanceInput>;
    repo?: Maybe<CustomSdmRepositoryInput>;
};

Auto generated input for type SdmRepoProvenance

type CustomSdmRepositoryInput

type CustomSdmRepositoryInput = {
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
};

Auto generated input for type SdmRepository

type CustomSdmVersionInput

type CustomSdmVersionInput = {
    branch?: Maybe<Scalars['String']>;
    repo?: Maybe<CustomSdmVersionRepositoryInput>;
    sha?: Maybe<Scalars['String']>;
    version?: Maybe<Scalars['String']>;
};

Auto generated input for type SdmVersion

type CustomSdmVersionRepositoryInput

type CustomSdmVersionRepositoryInput = {
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
};

Auto generated input for type SdmVersionRepository

type DeepLink

type DeepLink = (grr: RemoteRepoRef, sourceLocation: SourceLocation) => string;

Strategy for deep linking to a source control system.

type DefaultFacts

type DefaultFacts = Record<string, any>;

type DeletedBranch

type DeletedBranch = {
    __typename?: 'DeletedBranch';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** id of  DeletedBranch */
    id?: Maybe<Scalars['ID']>;
    /** name of  DeletedBranch */
    name?: Maybe<Scalars['String']>;
    /** timestamp of  DeletedBranch */
    timestamp?: Maybe<Scalars['String']>;
    /** DeletedBranch repo Repo */
    repo?: Maybe<Repo>;
    /** DeletedBranch commit Commit */
    commit?: Maybe<Commit>;
    /** DeletedBranch pullRequests PullRequest */
    pullRequests?: Maybe<Array<Maybe<PullRequest>>>;
};

DeletedBranch-Node

type DeletedBranchCommitArgs

type DeletedBranchCommitArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

DeletedBranch-Node

type DeletedBranchPullRequestsArgs

type DeletedBranchPullRequestsArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    prId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    merged?: Maybe<Scalars['Boolean']>;
    timestamp?: Maybe<Scalars['String']>;
    baseBranchName?: Maybe<Scalars['String']>;
    branchName?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    closedAt?: Maybe<Scalars['String']>;
    mergedAt?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_PullRequestOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    mergeStatus?: Maybe<MergeStatus>;
};

DeletedBranch-Node

type DeletedBranchRepoArgs

type DeletedBranchRepoArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    allowRebaseMerge?: Maybe<Scalars['Boolean']>;
    allowSquashMerge?: Maybe<Scalars['Boolean']>;
    allowMergeCommit?: Maybe<Scalars['Boolean']>;
    repoId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    defaultBranch?: Maybe<Scalars['String']>;
};

DeletedBranch-Node

type DeleteResourceProviderMutation

type DeleteResourceProviderMutation = {
    __typename?: 'Mutation';
} & Pick<Mutation, 'deleteResourceProvider'>;

type DeleteResourceProviderMutationVariables

type DeleteResourceProviderMutationVariables = {
    id: Scalars['ID'];
};

type DeleteTeamConfigurationMutation

type DeleteTeamConfigurationMutation = {
    __typename?: 'Mutation';
} & {
    deleteTeamConfiguration?: Maybe<
        {
            __typename?: 'TeamConfiguration';
        } & Pick<TeamConfiguration, 'name' | 'namespace'>
    >;
};

type DeleteTeamConfigurationMutationVariables

type DeleteTeamConfigurationMutationVariables = {
    namespace: Scalars['String'];
    name: Scalars['String'];
};

type Deployment

type Deployment = {
    __typename?: 'Deployment';
    commit?: Maybe<DeploymentCommit>;
    environment?: Maybe<Scalars['String']>;
    ts?: Maybe<Scalars['Int']>;
    /** The ID of this Deployment */
    id?: Maybe<Scalars['ID']>;
};

type DeploymentCommit

type DeploymentCommit = {
    __typename?: 'DeploymentCommit';
    owner?: Maybe<Scalars['String']>;
    repo?: Maybe<Scalars['String']>;
    sha?: Maybe<Scalars['String']>;
};

type DeploymentCommitArgs

type DeploymentCommitArgs = {
    sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    repo?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type DeprecatedPushImpact

type DeprecatedPushImpact = {
    __typename?: 'DeprecatedPushImpact';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** id of  PushImpact */
    id?: Maybe<Scalars['ID']>;
    /** url of  PushImpact */
    url?: Maybe<Scalars['String']>;
    /** data of  PushImpact */
    data?: Maybe<Scalars['String']>;
    /** PushImpact push Push */
    push?: Maybe<Push>;
};

PushImpact-Node

type DeprecatedPushImpactPushArgs

type DeprecatedPushImpactPushArgs = {
    id?: Maybe<Scalars['ID']>;
    timestamp?: Maybe<Scalars['String']>;
    branch?: Maybe<Scalars['String']>;
};

PushImpact-Node

type DockerHubInput

type DockerHubInput = {
    name: Scalars['String'];
    owner?: Maybe<Scalars['String']>;
    namespace: Scalars['String'];
};

type DockerHubRegistryProvider

type DockerHubRegistryProvider = ResourceProvider &
    DockerRegistry & {
        __typename?: 'DockerHubRegistryProvider';
        url: Scalars['String'];
        namespace: Scalars['String'];
        registryName: Scalars['String'];
        _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
        _id: Scalars['Int'];
        id: Scalars['ID'];
        name: Scalars['String'];
        team: Team;
        authProviderId?: Maybe<Scalars['String']>;
        state?: Maybe<ResourceProviderState>;
        credential?: Maybe<Credential>;
        webhooks?: Maybe<Array<Maybe<Webhook>>>;
        createdAt: Scalars['String'];
        updatedAt: Scalars['String'];
        createdBy?: Maybe<Person>;
        updatedBy?: Maybe<Person>;
        metadata?: Maybe<ResourceProviderMetadata>;
        timestamp: Scalars['String'];
        dockerImages: Array<DockerRegistryImage>;
    };

type DockerHubRegistryProviderWebhooksArgs

type DockerHubRegistryProviderWebhooksArgs = {
    id?: Maybe<Scalars['ID']>;
};

type DockerImage

type DockerImage = {
    __typename?: 'DockerImage';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** image of  DockerImage */
    image?: Maybe<Scalars['String']>;
    /** imageName of  DockerImage */
    imageName?: Maybe<Scalars['String']>;
    /** timestamp of  DockerImage */
    timestamp?: Maybe<Scalars['String']>;
    /** DockerImage pods K8Pod */
    pods?: Maybe<Array<Maybe<K8Pod>>>;
    /** DockerImage commits Commit */
    commits?: Maybe<Array<Maybe<Commit>>>;
    /** DockerImage containers K8Container */
    containers?: Maybe<Array<Maybe<K8Container>>>;
};

DockerImage-Node

type DockerImageCommitsArgs

type DockerImageCommitsArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_CommitOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    timestamp?: Maybe<Scalars['String']>;
};

DockerImage-Node

type DockerImageContainersArgs

type DockerImageContainersArgs = {
    name?: Maybe<Scalars['String']>;
    imageName?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    environment?: Maybe<Scalars['String']>;
    containerJSON?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    stateReason?: Maybe<Scalars['String']>;
    ready?: Maybe<Scalars['Boolean']>;
    restartCount?: Maybe<Scalars['Int']>;
    statusJSON?: Maybe<Scalars['String']>;
    resourceVersion?: Maybe<Scalars['Int']>;
    orderBy?: Maybe<Array<Maybe<_K8ContainerOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    containerID?: Maybe<Scalars['String']>;
};

DockerImage-Node

type DockerImagePodsArgs

type DockerImagePodsArgs = {
    name?: Maybe<Scalars['String']>;
    phase?: Maybe<Scalars['String']>;
    environment?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    baseName?: Maybe<Scalars['String']>;
    namespace?: Maybe<Scalars['String']>;
    statusJSON?: Maybe<Scalars['String']>;
    host?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    specsJSON?: Maybe<Scalars['String']>;
    envJSON?: Maybe<Scalars['String']>;
    metadataJSON?: Maybe<Scalars['String']>;
    containersCrashLoopBackOff?: Maybe<Scalars['Boolean']>;
    orderBy?: Maybe<Array<Maybe<_K8PodOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    resourceVersion?: Maybe<Scalars['Int']>;
};

DockerImage-Node

type DockerRegistry

type DockerRegistry = {
    _id: Scalars['Int'];
    id: Scalars['ID'];
    url: Scalars['String'];
    name: Scalars['String'];
    timestamp: Scalars['String'];
    registryName: Scalars['String'];
    credential?: Maybe<Credential>;
    team: Team;
    dockerImages: Array<DockerRegistryImage>;
};

type DockerRegistryImage

type DockerRegistryImage = Resource & {
    __typename?: 'DockerRegistryImage';
    imageName: Scalars['String'];
    timestamp: Scalars['String'];
    dockerRegistry: DockerRegistry;
    commit?: Maybe<Commit>;
    id: Scalars['ID'];
    _id: Scalars['Int'];
};

type DockerRegistryImageInput

type DockerRegistryImageInput = {
    imageName: Scalars['String'];
    image?: Maybe<Scalars['String']>;
};

type DockerRegistryProvider

type DockerRegistryProvider = ResourceProvider & {
    __typename?: 'DockerRegistryProvider';
    name: Scalars['String'];
    type: DockerRegistryType;
    providerId?: Maybe<Scalars['String']>;
    url?: Maybe<Scalars['String']>;
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    _id: Scalars['Int'];
    id: Scalars['ID'];
    team: Team;
    authProviderId?: Maybe<Scalars['String']>;
    state?: Maybe<ResourceProviderState>;
    credential?: Maybe<Credential>;
    webhooks?: Maybe<Array<Maybe<Webhook>>>;
    createdAt: Scalars['String'];
    updatedAt: Scalars['String'];
    createdBy?: Maybe<Person>;
    updatedBy?: Maybe<Person>;
    metadata?: Maybe<ResourceProviderMetadata>;
};

Deprecated. Use explicit types. This is the legacy ResourceProvider type.

type DockerRegistryProviderAllQuery

type DockerRegistryProviderAllQuery = {
    __typename?: 'Query';
} & {
    DockerRegistryProvider?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'DockerRegistryProvider';
                } & Pick<DockerRegistryProvider, 'url' | 'name'> & {
                        credential?: Maybe<
                            | ({
                                  __typename?: 'OAuthToken';
                              } & Pick<OAuthToken, 'id'>)
                            | ({
                                  __typename?: 'Password';
                              } & Pick<Password, 'id'>)
                        >;
                    }
            >
        >
    >;
};

type DockerRegistryProviderAllQueryVariables

type DockerRegistryProviderAllQueryVariables = {};

type DockerRegistryProviderQuery

type DockerRegistryProviderQuery = {
    __typename?: 'Query';
} & {
    DockerRegistryProvider?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'DockerRegistryProvider';
                } & Pick<DockerRegistryProvider, 'url' | 'name'> & {
                        state?: Maybe<
                            {
                                __typename?: 'ResourceProviderState';
                            } & Pick<ResourceProviderState, 'error' | 'name'>
                        >;
                        credential?: Maybe<
                            | ({
                                  __typename?: 'OAuthToken';
                              } & Pick<OAuthToken, 'id'> & {
                                      owner: {
                                          __typename?: 'SCMId';
                                      } & Pick<ScmId, 'login'>;
                                  })
                            | ({
                                  __typename?: 'Password';
                              } & Pick<Password, 'id'> & {
                                      owner:
                                          | ({
                                                __typename?: 'SCMId';
                                            } & Pick<ScmId, 'login'>)
                                          | ({
                                                __typename?: 'GitHubId';
                                            } & Pick<GitHubId, 'login'>)
                                          | ({
                                                __typename?: 'GitHubAppResourceUser';
                                            } & Pick<GitHubAppResourceUser, 'login'>)
                                          | ({
                                                __typename?: 'GenericResourceUser';
                                            } & Pick<GenericResourceUser, 'login'>)
                                          | ({
                                                __typename?: 'SystemAccount';
                                            } & Pick<SystemAccount, 'login'>);
                                  })
                        >;
                    }
            >
        >
    >;
};

type DockerRegistryProviderQueryVariables

type DockerRegistryProviderQueryVariables = {
    name?: Maybe<Scalars['String']>;
};

type DockerRegistryProviderWebhooksArgs

type DockerRegistryProviderWebhooksArgs = {
    id?: Maybe<Scalars['ID']>;
};

Deprecated. Use explicit types. This is the legacy ResourceProvider type.

type EditorFactory

type EditorFactory<P> = (params: P, ctx: HandlerContext) => AnyProjectEditor<P>;

type Email

type Email = {
    __typename?: 'Email';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** address of  Email */
    address?: Maybe<Scalars['String']>;
    /** Email scmId SCMId */
    scmId?: Maybe<ScmId>;
    /** Email gitHubId GitHubId */
    gitHubId?: Maybe<GitHubId>;
    /** Email chatId ChatId */
    chatId?: Maybe<ChatId>;
    /** Email person Person */
    person?: Maybe<Person>;
};

Email-Node

type EmailChatIdArgs

type EmailChatIdArgs = {
    id?: Maybe<Scalars['ID']>;
    screenName?: Maybe<Scalars['String']>;
    userId?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    isAtomistBot?: Maybe<Scalars['String']>;
    isOwner?: Maybe<Scalars['String']>;
    isPrimaryOwner?: Maybe<Scalars['String']>;
    isAdmin?: Maybe<Scalars['String']>;
    isBot?: Maybe<Scalars['String']>;
    timezoneLabel?: Maybe<Scalars['String']>;
};

Email-Node

type EmailGitHubIdArgs

type EmailGitHubIdArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
};

Email-Node

type EmailInput

type EmailInput = {
    address: Scalars['String'];
};

type EmailPersonArgs

type EmailPersonArgs = {
    id?: Maybe<Scalars['ID']>;
    forename?: Maybe<Scalars['String']>;
    surname?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
};

Email-Node

type EmailScmIdArgs

type EmailScmIdArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    avatar?: Maybe<Scalars['String']>;
};

Email-Node

type EndpointVerificationListener

type EndpointVerificationListener = SdmListener<EndpointVerificationInvocation>;

type EnrichGoal

type EnrichGoal = (
    goal: SdmGoalMessage,
    pli: PushListenerInvocation
) => Promise<SdmGoalMessage>;

Enrich provided goal before it gets persisted and planned

type ErrorFinder

type ErrorFinder = (code: number, signal: string, log: WritableLog) => boolean;

Type that can react to the exit of a spawned child process, after Node has terminated without reporting an error. This is necessary only for commands that can return a zero exit status on failure or non-zero exit code on success. Implementations should return true if an error is found, false otherwise.

type EventsReportRow

type EventsReportRow = {
    __typename?: 'EventsReportRow';
    /** The start date-time of this row. */
    bucket: Scalars['String'];
    /** The number of chat events in this time bucket. */
    chatCount?: Maybe<Scalars['Int']>;
    /** The number of custom events in this time bucket. */
    customCount?: Maybe<Scalars['Int']>;
    /** The number of SCM events in this time bucket. */
    scmCount?: Maybe<Scalars['Int']>;
};

type ExecuteGoal

type ExecuteGoal = (r: GoalInvocation) => Promise<void | ExecuteGoalResult>;

Type of all goal invocation functions. This is a key extension point for SDMs.

type ExplicitCodeTransform

type ExplicitCodeTransform<P = NoParameters> = (
    p: Project,
    papi: PushAwareParametersInvocation<P>,
    params?: P
) => Promise<TransformResult>;

Compatible with CodeTransform but returns TransformResult. At the cost of greater ceremony, guarantees the return of more information.

type ExtractAuthor

type ExtractAuthor = (gi: GoalInvocation) => Promise<
    | {
          name: string;
          email: string;
      }
    | undefined
>;

Extract author information from the current goal invocation

type FingerprintAggregates

type FingerprintAggregates = {
    __typename?: 'FingerprintAggregates';
    /** How many repos contain this fingeprint type/name? */
    inRepos: Scalars['Int'];
    /** Latest semver available if the SourceFingerprint supports it */
    latestSemVerAvailable?: Maybe<SourceFingerprint>;
    /** Latest semver used if the SourceFingerprint supports it */
    latestSemVerUsed?: Maybe<SourceFingerprintStats>;
    /** Which value/sha has been most frequently seen? */
    mostFrequentlyUsed?: Maybe<SourceFingerprintStats>;
    /** Which value/sha has been most recently seen? */
    mostRecentlyUsed?: Maybe<SourceFingerprintStats>;
    /** How many repos have been seen in total? */
    totalRepos: Scalars['Int'];
    /** How many different values/shas are there for this type/name? */
    totalVariants: Scalars['Int'];
};

type FingerprintCounts

type FingerprintCounts = {
    __typename?: 'FingerprintCounts';
    count: Scalars['Int'];
    mostFrequentlyUsed?: Maybe<SourceFingerprint>;
    mostRecentlyUsed?: Maybe<SourceFingerprint>;
    types: Array<FingerprintTypeCount>;
};

type FingerprintDiff

type FingerprintDiff = {
    __typename?: 'FingerprintDiff';
    from?: Maybe<SourceFingerprint>;
    to?: Maybe<SourceFingerprint>;
};

type FingerprintedCommit

type FingerprintedCommit = {
    __typename?: 'FingerprintedCommit';
    analysis: Array<SourceFingerprint>;
    isDefaultBranch: Scalars['Boolean'];
    branch?: Maybe<Branch>;
    commit?: Maybe<Commit>;
    repo?: Maybe<Repo>;
};

A commit

type FingerprintInput

type FingerprintInput = {
    /** Optional data, such as dependency version */
    data?: Maybe<Scalars['String']>;
    /** Optional human readable string for this fingerprint */
    displayName?: Maybe<Scalars['String']>;
    /** Optional human readable string for the type (Aspect name) of this fingerprint */
    displayType?: Maybe<Scalars['String']>;
    /** Optional human readable string for the value of this fingerprint */
    displayValue?: Maybe<Scalars['String']>;
    /** The unique name for this fingerprint, such as the name of a dependency */
    name: Scalars['String'];
    /** The hash of this fingerprint - forms ID of a SourceFingerprint */
    sha: Scalars['String'];
};

For submitting new RepoFingerprints

type FingerprintsForCommitsInput

type FingerprintsForCommitsInput = {
    commitSha: Scalars['String'];
    repoId: Scalars['String'];
};

type FingerprintTarget

type FingerprintTarget = {
    __typename?: 'FingerprintTarget';
    fingerprint: SourceFingerprint;
};

type FingerprintTargetInput

type FingerprintTargetInput = {
    name: Scalars['String'];
    sha: Scalars['String'];
    type: Scalars['String'];
};

type FingerprintTypeCount

type FingerprintTypeCount = {
    __typename?: 'FingerprintTypeCount';
    count: Scalars['Int'];
    names: Array<FinterprintNameCount>;
    type: Scalars['String'];
};

type FinterprintNameCount

type FinterprintNameCount = {
    __typename?: 'FinterprintNameCount';
    count: Scalars['Int'];
    name: Scalars['String'];
};

type Fulfillment

type Fulfillment = Implementation | SideEffect;

type GenericResourceProvider

type GenericResourceProvider = ResourceProvider & {
    __typename?: 'GenericResourceProvider';
    name: Scalars['String'];
    type: Scalars['String'];
    providerId: Scalars['String'];
    url?: Maybe<Scalars['String']>;
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    _id: Scalars['Int'];
    id: Scalars['ID'];
    team: Team;
    authProviderId?: Maybe<Scalars['String']>;
    state?: Maybe<ResourceProviderState>;
    credential?: Maybe<Credential>;
    webhooks?: Maybe<Array<Maybe<Webhook>>>;
    createdAt: Scalars['String'];
    updatedAt: Scalars['String'];
    createdBy?: Maybe<Person>;
    updatedBy?: Maybe<Person>;
    metadata?: Maybe<ResourceProviderMetadata>;
};

type GenericResourceProviderQuery

type GenericResourceProviderQuery = {
    __typename?: 'Query';
} & {
    GenericResourceProvider?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'GenericResourceProvider';
                } & Pick<GenericResourceProvider, 'url' | 'name'> & {
                        credential?: Maybe<
                            | ({
                                  __typename?: 'OAuthToken';
                              } & Pick<OAuthToken, 'id'>)
                            | ({
                                  __typename?: 'Password';
                              } & Pick<Password, 'id'>)
                        >;
                    }
            >
        >
    >;
};

type GenericResourceProviderQueryVariables

type GenericResourceProviderQueryVariables = {
    name?: Maybe<Scalars['String']>;
    type: Scalars['String'];
};

type GenericResourceProviderWebhooksArgs

type GenericResourceProviderWebhooksArgs = {
    id?: Maybe<Scalars['ID']>;
};

type GenericResourceUser

type GenericResourceUser = ResourceUser & {
    __typename?: 'GenericResourceUser';
    person?: Maybe<Person>;
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    id: Scalars['ID'];
    _id?: Maybe<Scalars['Int']>;
    credential?: Maybe<Credential>;
    provider: ResourceProvider;
    login: Scalars['String'];
};

type GenericResourceUserProviderArgs

type GenericResourceUserProviderArgs = {
    id?: Maybe<Scalars['ID']>;
};

type GenericSourceFingerprint

type GenericSourceFingerprint = SourceFingerprint & {
    __typename?: 'GenericSourceFingerprint';
    data?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    displayType?: Maybe<Scalars['String']>;
    displayValue?: Maybe<Scalars['String']>;
    id: Scalars['ID'];
    name: Scalars['String'];
    sha: Scalars['String'];
    type: Scalars['String'];
};

type GitHubAppInstallation

type GitHubAppInstallation = {
    __typename?: 'GitHubAppInstallation';
    _id: Scalars['Int'];
    installationId: Scalars['Int'];
    permissions?: Maybe<Scalars['String']>;
    id: Scalars['ID'];
    owner: Scalars['String'];
    ownerType: OwnerType;
    state: Scalars['String'];
    avatarUrl?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    gitHubAppResourceProvider: GitHubAppResourceProvider;
    token?: Maybe<GitHubAppInstallationToken>;
};

type GitHubAppInstallationByOwnerQuery

type GitHubAppInstallationByOwnerQuery = {
    __typename?: 'Query';
} & {
    GitHubAppInstallation?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'GitHubAppInstallation';
                } & {
                    token?: Maybe<
                        {
                            __typename?: 'GitHubAppInstallationToken';
                        } & Pick<GitHubAppInstallationToken, 'secret'>
                    >;
                }
            >
        >
    >;
};

type GitHubAppInstallationByOwnerQueryVariables

type GitHubAppInstallationByOwnerQueryVariables = {
    name?: Maybe<Scalars['String']>;
};

type GitHubAppInstallationToken

type GitHubAppInstallationToken = {
    __typename?: 'GitHubAppInstallationToken';
    secret: Scalars['String'];
    permissions: Scalars['String'];
};

type GitHubAppResourceProvider

type GitHubAppResourceProvider = ResourceProvider &
    NpmRegistryProvider & {
        __typename?: 'GitHubAppResourceProvider';
        name: Scalars['String'];
        url: Scalars['String'];
        providerId: Scalars['String'];
        /** private is this provider reachable on the public internet */
        private: Scalars['Boolean'];
        apiUrl: Scalars['String'];
        gitUrl: Scalars['String'];
        providerType: ProviderType;
        /** the id of the atomist github app as provided by github */
        applicationId: Scalars['Int'];
        /** the name of the atomist github app */
        applicationName: Scalars['String'];
        orgs?: Maybe<Array<Maybe<Org>>>;
        gitHubAppInstallations?: Maybe<Array<Maybe<GitHubAppInstallation>>>;
        _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
        _id: Scalars['Int'];
        id: Scalars['ID'];
        team: Team;
        authProviderId?: Maybe<Scalars['String']>;
        state?: Maybe<ResourceProviderState>;
        credential?: Maybe<Credential>;
        webhooks?: Maybe<Array<Maybe<Webhook>>>;
        createdAt: Scalars['String'];
        updatedAt: Scalars['String'];
        createdBy?: Maybe<Person>;
        updatedBy?: Maybe<Person>;
        metadata?: Maybe<ResourceProviderMetadata>;
        scope?: Maybe<Scalars['String']>;
    };

type GitHubAppResourceProviderGitHubAppInstallationsArgs

type GitHubAppResourceProviderGitHubAppInstallationsArgs = {
    installationId?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_GitHubAppInstallationOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    ownerType?: Maybe<OwnerType>;
};

type GitHubAppResourceProviderOrgsArgs

type GitHubAppResourceProviderOrgsArgs = {
    owner?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_OrgOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    ownerType?: Maybe<OwnerType>;
};

type GitHubAppResourceProviderQuery

type GitHubAppResourceProviderQuery = {
    __typename?: 'Query';
} & {
    GitHubAppResourceProvider?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'GitHubAppResourceProvider';
                } & Pick<GitHubAppResourceProvider, 'id' | 'providerId'>
            >
        >
    >;
};

type GitHubAppResourceProviderQueryVariables

type GitHubAppResourceProviderQueryVariables = {};

type GitHubAppResourceProviderWebhooksArgs

type GitHubAppResourceProviderWebhooksArgs = {
    id?: Maybe<Scalars['ID']>;
};

type GitHubAppResourceUser

type GitHubAppResourceUser = ResourceUser & {
    __typename?: 'GitHubAppResourceUser';
    gitHubAppProvider: GitHubAppResourceProvider;
    gitHubAppInstallations?: Maybe<Array<GitHubAppUserInstallation>>;
    person?: Maybe<Person>;
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    id: Scalars['ID'];
    _id?: Maybe<Scalars['Int']>;
    credential?: Maybe<Credential>;
    provider: ResourceProvider;
    login: Scalars['String'];
};

type GitHubAppResourceUserProviderArgs

type GitHubAppResourceUserProviderArgs = {
    id?: Maybe<Scalars['ID']>;
};

type GitHubAppUserInstallation

type GitHubAppUserInstallation = {
    __typename?: 'GitHubAppUserInstallation';
    installationId: Scalars['Int'];
    permissions?: Maybe<Scalars['String']>;
    owner: Scalars['String'];
    ownerType: OwnerType;
    avatarUrl?: Maybe<Scalars['String']>;
};

type GitHubId

type GitHubId = ResourceUser & {
    __typename?: 'GitHubId';
    /** name of  GitHubId */
    name?: Maybe<Scalars['String']>;
    credential?: Maybe<OAuthToken>;
    provider: ScmProvider;
    /** GitHubId emails Email */
    emails?: Maybe<Array<Maybe<Email>>>;
    /** GitHubId person Person */
    person?: Maybe<Person>;
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    id: Scalars['ID'];
    _id?: Maybe<Scalars['Int']>;
    login: Scalars['String'];
};

GitHubId-Node

type GitHubIdEmailsArgs

type GitHubIdEmailsArgs = {
    orderBy?: Maybe<Array<Maybe<_EmailOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    address?: Maybe<Scalars['String']>;
};

GitHubId-Node

type GitHubIdPersonArgs

type GitHubIdPersonArgs = {
    id?: Maybe<Scalars['ID']>;
    forename?: Maybe<Scalars['String']>;
    surname?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
};

GitHubId-Node

type GitHubIdProviderArgs

type GitHubIdProviderArgs = {
    id?: Maybe<Scalars['ID']>;
};

GitHubId-Node

type GitHubLoginQuery

type GitHubLoginQuery = {
    __typename?: 'Query';
} & {
    Team?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Team';
                } & {
                    chatTeams?: Maybe<
                        Array<
                            Maybe<
                                {
                                    __typename?: 'ChatTeam';
                                } & {
                                    members?: Maybe<
                                        Array<
                                            Maybe<
                                                {
                                                    __typename?: 'ChatId';
                                                } & {
                                                    person?: Maybe<
                                                        {
                                                            __typename?: 'Person';
                                                        } & {
                                                            gitHubId?: Maybe<
                                                                {
                                                                    __typename?: 'GitHubId';
                                                                } & Pick<
                                                                    GitHubId,
                                                                    'login'
                                                                >
                                                            >;
                                                        }
                                                    >;
                                                }
                                            >
                                        >
                                    >;
                                }
                            >
                        >
                    >;
                    orgs?: Maybe<
                        Array<
                            Maybe<
                                {
                                    __typename?: 'Org';
                                } & {
                                    provider?: Maybe<
                                        {
                                            __typename?: 'GitHubProvider';
                                        } & Pick<GitHubProvider, 'apiUrl'>
                                    >;
                                }
                            >
                        >
                    >;
                }
            >
        >
    >;
};

type GitHubLoginQueryVariables

type GitHubLoginQueryVariables = {
    userId: Scalars['String'];
    owner: Scalars['String'];
    providerId: Scalars['String'];
};

type GitHubNpmRegistryProvider

type GitHubNpmRegistryProvider = ResourceProvider &
    NpmRegistryProvider & {
        __typename?: 'GitHubNpmRegistryProvider';
        url: Scalars['String'];
        scope?: Maybe<Scalars['String']>;
        gitHubAppInstallation: GitHubAppInstallation;
        installationId: Scalars['String'];
        credential?: Maybe<Credential>;
        _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
        _id: Scalars['Int'];
        id: Scalars['ID'];
        name?: Maybe<Scalars['String']>;
        team: Team;
        authProviderId?: Maybe<Scalars['String']>;
        state?: Maybe<ResourceProviderState>;
        webhooks?: Maybe<Array<Maybe<Webhook>>>;
        createdAt: Scalars['String'];
        updatedAt: Scalars['String'];
        createdBy?: Maybe<Person>;
        updatedBy?: Maybe<Person>;
        metadata?: Maybe<ResourceProviderMetadata>;
    };

type GitHubNpmRegistryProviderInput

type GitHubNpmRegistryProviderInput = {
    name?: Maybe<Scalars['String']>;
};

type GitHubNpmRegistryProviderWebhooksArgs

type GitHubNpmRegistryProviderWebhooksArgs = {
    id?: Maybe<Scalars['ID']>;
};

type GitHubProvider

type GitHubProvider = {
    __typename?: 'GitHubProvider';
    _id: Scalars['Int'];
    id: Scalars['ID'];
    url?: Maybe<Scalars['String']>;
    providerId: Scalars['String'];
    private?: Maybe<Scalars['Boolean']>;
    apiUrl: Scalars['String'];
    gitUrl: Scalars['String'];
    providerType?: Maybe<ProviderType>;
    team: Team;
};

GitHubProvider-Node

type GitHubProviderTeamArgs

type GitHubProviderTeamArgs = {
    id?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    iconUrl?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
};

GitHubProvider-Node

type GitHubStatusContext

type GitHubStatusContext = string;

type GoalApprovalRequestVoteDecisionManager

type GoalApprovalRequestVoteDecisionManager = (
    ...votes: GoalApprovalRequestVoteResult[]
) => GoalApprovalRequestVote;

Decide resulting vote on a set of votes

type GoalApprovalRequestVoter

type GoalApprovalRequestVoter = (
    garvi: GoalApprovalRequestVoterInvocation
) => Promise<GoalApprovalRequestVoteResult>;

Voter on a request to approve a goal

type GoalCompletionListener

type GoalCompletionListener = SdmListener<GoalCompletionListenerInvocation>;

type GoalComponent

type GoalComponent = Goal | Goal[] | Goals;

Type used in constructing goals

type GoalEnvironment

type GoalEnvironment = '0-code/' | '1-staging/' | '2-prod/' | '8-doom/';

type GoalExecutionListener

type GoalExecutionListener = SdmListener<GoalExecutionListenerInvocation>;

type GoalFulfillment

type GoalFulfillment = GoalImplementation | GoalSideEffect;

type GoalProjectListener

type GoalProjectListener = (
    p: GitProject,
    r: GoalInvocation,
    event: GoalProjectListenerEvent
) => Promise<void | ExecuteGoalResult>;

type GoalSetter

type GoalSetter<F extends SdmContext = PushListenerInvocation> = Mapping<F, Goals>;

A GoalSetter decides what goals to run depending on repo contents and characteristics of the push. It is fundamental to determining the flow after the push: for example: do we want to run a code scan?; do we want to build?; do we want to deploy?
Returns
Goals or undefined if it doesn't like the push or understand the repo

type GoalsSetListener

type GoalsSetListener = SdmListener<GoalsSetListenerInvocation>;

type GoogleCloudPlatformInput

type GoogleCloudPlatformInput = {
    name: Scalars['String'];
};

type GoogleCloudPlatformProvider

type GoogleCloudPlatformProvider = ResourceProvider & {
    __typename?: 'GoogleCloudPlatformProvider';
    name: Scalars['String'];
    timestamp: Scalars['String'];
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    _id: Scalars['Int'];
    id: Scalars['ID'];
    team: Team;
    authProviderId?: Maybe<Scalars['String']>;
    state?: Maybe<ResourceProviderState>;
    credential?: Maybe<Credential>;
    webhooks?: Maybe<Array<Maybe<Webhook>>>;
    createdAt: Scalars['String'];
    updatedAt: Scalars['String'];
    createdBy?: Maybe<Person>;
    updatedBy?: Maybe<Person>;
    metadata?: Maybe<ResourceProviderMetadata>;
};

type GoogleCloudPlatformProviderWebhooksArgs

type GoogleCloudPlatformProviderWebhooksArgs = {
    id?: Maybe<Scalars['ID']>;
};

type GoogleContainerRegistryInput

type GoogleContainerRegistryInput = {
    name: Scalars['String'];
    projectId: Scalars['String'];
    registryHost: Scalars['String'];
};

type GoogleContainerRegistryProvider

type GoogleContainerRegistryProvider = ResourceProvider &
    DockerRegistry & {
        __typename?: 'GoogleContainerRegistryProvider';
        url: Scalars['String'];
        registryHost: Scalars['String'];
        projectId: Scalars['String'];
        registryName: Scalars['String'];
        _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
        _id: Scalars['Int'];
        id: Scalars['ID'];
        name: Scalars['String'];
        team: Team;
        authProviderId?: Maybe<Scalars['String']>;
        state?: Maybe<ResourceProviderState>;
        credential?: Maybe<Credential>;
        webhooks?: Maybe<Array<Maybe<Webhook>>>;
        createdAt: Scalars['String'];
        updatedAt: Scalars['String'];
        createdBy?: Maybe<Person>;
        updatedBy?: Maybe<Person>;
        metadata?: Maybe<ResourceProviderMetadata>;
        timestamp: Scalars['String'];
        dockerImages: Array<DockerRegistryImage>;
    };

type GoogleContainerRegistryProviderWebhooksArgs

type GoogleContainerRegistryProviderWebhooksArgs = {
    id?: Maybe<Scalars['ID']>;
};

type HerokuApp

type HerokuApp = {
    __typename?: 'HerokuApp';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** app of  HerokuApp */
    app?: Maybe<Scalars['String']>;
    /** url of  HerokuApp */
    url?: Maybe<Scalars['String']>;
    /** timestamp of  HerokuApp */
    timestamp?: Maybe<Scalars['String']>;
    /** user of  HerokuApp */
    user?: Maybe<Scalars['String']>;
    /** appId of  HerokuApp */
    appId?: Maybe<Scalars['String']>;
    /** release of  HerokuApp */
    release?: Maybe<Scalars['String']>;
    /** HerokuApp commits Commit */
    commits?: Maybe<Array<Maybe<Commit>>>;
};

HerokuApp-Node

type HerokuAppCommitsArgs

type HerokuAppCommitsArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_CommitOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    timestamp?: Maybe<Scalars['String']>;
};

HerokuApp-Node

type HmacSha1AuthInput

type HmacSha1AuthInput = {
    /** shared secret */
    secret: Scalars['String'];
    /** http header in which to find the hash */
    header?: Maybe<Scalars['String']>;
};

type ImageLinked

type ImageLinked = {
    __typename?: 'ImageLinked';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** timestamp of  ImageLinked */
    timestamp?: Maybe<Scalars['String']>;
    /** ImageLinked image DockerImage */
    image?: Maybe<DockerImage>;
    /** ImageLinked commit Commit */
    commit?: Maybe<Commit>;
};

ImageLinked-Node

type ImageLinkedCommitArgs

type ImageLinkedCommitArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

ImageLinked-Node

type ImageLinkedImageArgs

type ImageLinkedImageArgs = {
    image?: Maybe<Scalars['String']>;
    imageName?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

ImageLinked-Node

type InProcessSdmGoalSetsQuery

type InProcessSdmGoalSetsQuery = {
    __typename?: 'Query';
} & {
    SdmGoalSet?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SdmGoalSet';
                } & Pick<
                    SdmGoalSet,
                    'sha' | 'branch' | 'goalSet' | 'goalSetId' | 'state' | 'ts'
                > & {
                        goals?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'SdmGoalName';
                                    } & Pick<SdmGoalName, 'name' | 'uniqueName'>
                                >
                            >
                        >;
                        provenance?: Maybe<
                            {
                                __typename?: 'SdmProvenance';
                            } & Pick<
                                SdmProvenance,
                                | 'channelId'
                                | 'correlationId'
                                | 'name'
                                | 'registration'
                                | 'ts'
                                | 'userId'
                                | 'version'
                            >
                        >;
                        repo?: Maybe<
                            {
                                __typename?: 'SdmRepository';
                            } & Pick<SdmRepository, 'name' | 'owner' | 'providerId'>
                        >;
                        tags?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'SdmGoalSetTag';
                                    } & Pick<SdmGoalSetTag, 'name' | 'value'>
                                >
                            >
                        >;
                    }
            >
        >
    >;
};

type InProcessSdmGoalSetsQueryVariables

type InProcessSdmGoalSetsQueryVariables = {
    fetch: Scalars['Int'];
    registration?: Maybe<Array<Scalars['String']>>;
    offset: Scalars['Int'];
};

type InProcessSdmGoalsQuery

type InProcessSdmGoalsQuery = {
    __typename?: 'Query';
} & {
    SdmGoal?: Maybe<
        Array<
            Maybe<
                ({
                    __typename?: 'SdmGoal';
                } & Pick<
                    SdmGoal,
                    | 'environment'
                    | 'uniqueName'
                    | 'name'
                    | 'sha'
                    | 'branch'
                    | 'description'
                    | 'url'
                    | 'externalUrl'
                    | 'state'
                    | 'phase'
                    | 'externalKey'
                    | 'goalSet'
                    | 'registration'
                    | 'goalSetId'
                    | 'ts'
                    | 'error'
                    | 'retryFeasible'
                    | 'approvalRequired'
                    | 'preApprovalRequired'
                    | 'parameters'
                    | 'data'
                    | 'version'
                    | 'signature'
                > & {
                        fulfillment?: Maybe<
                            {
                                __typename?: 'SdmGoalFulfillment';
                            } & Pick<
                                SdmGoalFulfillment,
                                'method' | 'registration' | 'name'
                            >
                        >;
                        externalUrls?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'SdmExternalUrl';
                                    } & Pick<SdmExternalUrl, 'label' | 'url'>
                                >
                            >
                        >;
                        preConditions?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'SdmCondition';
                                    } & Pick<
                                        SdmCondition,
                                        'environment' | 'uniqueName' | 'name'
                                    >
                                >
                            >
                        >;
                        approval?: Maybe<
                            {
                                __typename?: 'SdmProvenance';
                            } & Pick<
                                SdmProvenance,
                                | 'correlationId'
                                | 'registration'
                                | 'name'
                                | 'version'
                                | 'ts'
                                | 'userId'
                                | 'channelId'
                            >
                        >;
                        preApproval?: Maybe<
                            {
                                __typename?: 'SdmProvenance';
                            } & Pick<
                                SdmProvenance,
                                | 'correlationId'
                                | 'registration'
                                | 'name'
                                | 'version'
                                | 'ts'
                                | 'userId'
                                | 'channelId'
                            >
                        >;
                        provenance?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'SdmProvenance';
                                    } & Pick<
                                        SdmProvenance,
                                        | 'correlationId'
                                        | 'registration'
                                        | 'name'
                                        | 'version'
                                        | 'ts'
                                        | 'userId'
                                        | 'channelId'
                                    >
                                >
                            >
                        >;
                        descriptions?: Maybe<
                            {
                                __typename?: 'SdmGoalDescriptions';
                            } & Pick<
                                SdmGoalDescriptions,
                                | 'canceled'
                                | 'completed'
                                | 'failed'
                                | 'inProcess'
                                | 'planned'
                                | 'requested'
                                | 'stopped'
                                | 'skipped'
                                | 'waitingForApproval'
                                | 'waitingForPreApproval'
                            >
                        >;
                        push?: Maybe<
                            {
                                __typename?: 'Push';
                            } & PushFieldsFragment
                        >;
                    }) &
                    SdmGoalRepoFragment
            >
        >
    >;
};

type InProcessSdmGoalsQueryVariables

type InProcessSdmGoalsQueryVariables = {
    registration: Array<Scalars['String']>;
};

type InterpretLog

type InterpretLog<D = any> = (log: string) => InterpretedLog<D> | undefined;

Function that can try to interpret a log for display to a user. Return undefined if the log cannot be interpreted.

type Issue

type Issue = {
    __typename?: 'Issue';
    _id?: Maybe<Scalars['Int']>;
    url?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    name?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<IssueState>;
    timestamp?: Maybe<Scalars['String']>;
    action?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    closedAt?: Maybe<Scalars['String']>;
    /** Issue repo Repo */
    repo: Repo;
    /** Issue resolvingCommits Commit */
    resolvingCommits?: Maybe<Array<Maybe<Commit>>>;
    /** Issue openedBy SCMId */
    openedBy?: Maybe<ScmId>;
    /** Issue closedBy SCMId */
    closedBy?: Maybe<ScmId>;
    /** Issue labels Label */
    labels?: Maybe<Array<Maybe<Label>>>;
    /** Issue assignees SCMId */
    assignees?: Maybe<Array<Maybe<ScmId>>>;
    /** Issue lastAssignedBy SCMId */
    lastAssignedBy?: Maybe<ScmId>;
    /** Issue comments Comment */
    comments?: Maybe<Array<Maybe<Comment>>>;
};

type IssueAssigneesArgs

type IssueAssigneesArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_ScmIdOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    avatar?: Maybe<Scalars['String']>;
};

type IssueClosedByArgs

type IssueClosedByArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    avatar?: Maybe<Scalars['String']>;
};

type IssueCommentsArgs

type IssueCommentsArgs = {
    id?: Maybe<Scalars['ID']>;
    body?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    commentId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    path?: Maybe<Scalars['String']>;
    position?: Maybe<Scalars['String']>;
    htmlUrl?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_CommentOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    commentType?: Maybe<CommentCommentType>;
};

type IssueLabelsArgs

type IssueLabelsArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    default?: Maybe<Scalars['String']>;
    color?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_LabelOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type IssueLastAssignedByArgs

type IssueLastAssignedByArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    avatar?: Maybe<Scalars['String']>;
};

type IssueOpenedByArgs

type IssueOpenedByArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    avatar?: Maybe<Scalars['String']>;
};

type IssueRelationship

type IssueRelationship = {
    __typename?: 'IssueRelationship';
    relationshipId?: Maybe<Scalars['String']>;
    source?: Maybe<IssueRelationshipIssue>;
    state?: Maybe<Scalars['String']>;
    target?: Maybe<IssueRelationshipIssue>;
    type?: Maybe<Scalars['String']>;
    /** The ID of this IssueRelationship */
    id?: Maybe<Scalars['ID']>;
};

type IssueRelationshipIssue

type IssueRelationshipIssue = {
    __typename?: 'IssueRelationshipIssue';
    issue?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    repo?: Maybe<Scalars['String']>;
};

type IssueRelationshipSourceArgs

type IssueRelationshipSourceArgs = {
    issue?: Maybe<Array<Maybe<Scalars['String']>>>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    repo?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type IssueRelationshipTargetArgs

type IssueRelationshipTargetArgs = {
    issue?: Maybe<Array<Maybe<Scalars['String']>>>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    repo?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type IssueRepoArgs

type IssueRepoArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    allowRebaseMerge?: Maybe<Scalars['Boolean']>;
    allowSquashMerge?: Maybe<Scalars['Boolean']>;
    allowMergeCommit?: Maybe<Scalars['Boolean']>;
    repoId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    defaultBranch?: Maybe<Scalars['String']>;
};

type IssueResolvingCommitsArgs

type IssueResolvingCommitsArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_CommitOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type JFrogDockerRegistryInput

type JFrogDockerRegistryInput = {
    name: Scalars['String'];
    url: Scalars['String'];
};

type JFrogDockerRegistryProvider

type JFrogDockerRegistryProvider = ResourceProvider &
    DockerRegistry & {
        __typename?: 'JFrogDockerRegistryProvider';
        url: Scalars['String'];
        registryName: Scalars['String'];
        _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
        _id: Scalars['Int'];
        id: Scalars['ID'];
        name: Scalars['String'];
        team: Team;
        authProviderId?: Maybe<Scalars['String']>;
        state?: Maybe<ResourceProviderState>;
        credential?: Maybe<Credential>;
        webhooks?: Maybe<Array<Maybe<Webhook>>>;
        createdAt: Scalars['String'];
        updatedAt: Scalars['String'];
        createdBy?: Maybe<Person>;
        updatedBy?: Maybe<Person>;
        metadata?: Maybe<ResourceProviderMetadata>;
        timestamp: Scalars['String'];
        dockerImages: Array<DockerRegistryImage>;
    };

type JFrogDockerRegistryProviderWebhooksArgs

type JFrogDockerRegistryProviderWebhooksArgs = {
    id?: Maybe<Scalars['ID']>;
};

type Job

type Job = {
    __typename?: 'Job';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** When this job gets triggered */
    when?: Maybe<Scalars['String']>;
    /** Is this job triggered manually? */
    manual?: Maybe<Scalars['Boolean']>;
    /** The name of this job */
    name?: Maybe<Scalars['String']>;
    /** The source id of this job. The ID assigned to it by its provider */
    jobId?: Maybe<Scalars['ID']>;
    /** When this job started as an ISO8601 string. Blank until started. */
    startedAt?: Maybe<Scalars['String']>;
    /** When this job finished as an ISO8601 string. Blank until finished. */
    finishedAt?: Maybe<Scalars['String']>;
    /** The status of this job. Blank until started. */
    status?: Maybe<JobStatus>;
    /** The runner for this job. Blank until started. */
    runner?: Maybe<Scalars['String']>;
    /** The stage this job is associated with */
    stage?: Maybe<Stage>;
};

Job-Node

type K8Container

type K8Container = {
    __typename?: 'K8Container';
    _id?: Maybe<Scalars['Int']>;
    name?: Maybe<Scalars['String']>;
    imageName?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    environment?: Maybe<Scalars['String']>;
    clusterName: Scalars['String'];
    containerJSON?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    stateReason?: Maybe<Scalars['String']>;
    ready?: Maybe<Scalars['Boolean']>;
    restartCount?: Maybe<Scalars['Int']>;
    statusJSON?: Maybe<Scalars['String']>;
    resourceVersion?: Maybe<Scalars['Int']>;
    containerID?: Maybe<Scalars['String']>;
    image?: Maybe<DockerImage>;
    /** K8Container pod K8Pod */
    pod?: Maybe<K8Pod>;
};

K8Container-Node

type K8ContainerImageArgs

type K8ContainerImageArgs = {
    image?: Maybe<Scalars['String']>;
    imageName?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

K8Container-Node

type K8ContainerPodArgs

type K8ContainerPodArgs = {
    name?: Maybe<Scalars['String']>;
    phase?: Maybe<Scalars['String']>;
    environment?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    baseName?: Maybe<Scalars['String']>;
    namespace?: Maybe<Scalars['String']>;
    statusJSON?: Maybe<Scalars['String']>;
    host?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    specsJSON?: Maybe<Scalars['String']>;
    envJSON?: Maybe<Scalars['String']>;
    metadataJSON?: Maybe<Scalars['String']>;
    containersCrashLoopBackOff?: Maybe<Scalars['Boolean']>;
    resourceVersion?: Maybe<Scalars['Int']>;
};

K8Container-Node

type K8Pod

type K8Pod = {
    __typename?: 'K8Pod';
    _id?: Maybe<Scalars['Int']>;
    name?: Maybe<Scalars['String']>;
    phase?: Maybe<Scalars['String']>;
    environment?: Maybe<Scalars['String']>;
    clusterName: Scalars['String'];
    timestamp?: Maybe<Scalars['String']>;
    baseName?: Maybe<Scalars['String']>;
    namespace?: Maybe<Scalars['String']>;
    statusJSON?: Maybe<Scalars['String']>;
    host?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    specsJSON?: Maybe<Scalars['String']>;
    envJSON?: Maybe<Scalars['String']>;
    metadataJSON?: Maybe<Scalars['String']>;
    containersCrashLoopBackOff?: Maybe<Scalars['Boolean']>;
    resourceVersion?: Maybe<Scalars['Int']>;
    /** K8Pod images DockerImage */
    images?: Maybe<Array<Maybe<DockerImage>>>;
    /** K8Pod containers K8Container */
    containers?: Maybe<Array<Maybe<K8Container>>>;
};

K8Pod-Node

type K8PodContainersArgs

type K8PodContainersArgs = {
    name?: Maybe<Scalars['String']>;
    imageName?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    environment?: Maybe<Scalars['String']>;
    containerJSON?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    stateReason?: Maybe<Scalars['String']>;
    ready?: Maybe<Scalars['Boolean']>;
    restartCount?: Maybe<Scalars['Int']>;
    statusJSON?: Maybe<Scalars['String']>;
    resourceVersion?: Maybe<Scalars['Int']>;
    orderBy?: Maybe<Array<Maybe<_K8ContainerOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    containerID?: Maybe<Scalars['String']>;
};

K8Pod-Node

type K8PodImagesArgs

type K8PodImagesArgs = {
    image?: Maybe<Scalars['String']>;
    imageName?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_DockerImageOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    timestamp?: Maybe<Scalars['String']>;
};

K8Pod-Node

type KubernetesCluster

type KubernetesCluster = {
    __typename?: 'KubernetesCluster';
    name: Scalars['String'];
};

type KubernetesClusterInput

type KubernetesClusterInput = {
    name: Scalars['String'];
};

type KubernetesClusterProvider

type KubernetesClusterProvider = ResourceProvider & {
    __typename?: 'KubernetesClusterProvider';
    name: Scalars['String'];
    timestamp: Scalars['String'];
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    _id: Scalars['Int'];
    id: Scalars['ID'];
    team: Team;
    authProviderId?: Maybe<Scalars['String']>;
    state?: Maybe<ResourceProviderState>;
    credential?: Maybe<Credential>;
    webhooks?: Maybe<Array<Maybe<Webhook>>>;
    createdAt: Scalars['String'];
    updatedAt: Scalars['String'];
    createdBy?: Maybe<Person>;
    updatedBy?: Maybe<Person>;
    metadata?: Maybe<ResourceProviderMetadata>;
};

type KubernetesClusterProviderWebhooksArgs

type KubernetesClusterProviderWebhooksArgs = {
    id?: Maybe<Scalars['ID']>;
};

type KubernetesDeployRequestedSdmGoalSubscription

type KubernetesDeployRequestedSdmGoalSubscription = {
    __typename?: 'Subscription';
} & {
    SdmGoal?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SdmGoal';
                } & Pick<
                    SdmGoal,
                    | 'uniqueName'
                    | 'name'
                    | 'id'
                    | 'environment'
                    | 'sha'
                    | 'branch'
                    | 'description'
                    | 'url'
                    | 'externalUrl'
                    | 'state'
                    | 'externalKey'
                    | 'goalSet'
                    | 'registration'
                    | 'goalSetId'
                    | 'phase'
                    | 'ts'
                    | 'error'
                    | 'retryFeasible'
                    | 'approvalRequired'
                    | 'preApprovalRequired'
                    | 'data'
                    | 'parameters'
                    | 'version'
                > & {
                        push?: Maybe<
                            {
                                __typename?: 'Push';
                            } & Pick<Push, 'id' | 'timestamp' | 'branch'> & {
                                    before?: Maybe<
                                        {
                                            __typename?: 'Commit';
                                        } & Pick<Commit, 'sha' | 'message'> & {
                                                committer?: Maybe<
                                                    {
                                                        __typename?: 'SCMId';
                                                    } & Pick<ScmId, 'login'>
                                                >;
                                            }
                                    >;
                                    after?: Maybe<
                                        {
                                            __typename?: 'Commit';
                                        } & Pick<Commit, 'sha' | 'message'> & {
                                                committer?: Maybe<
                                                    {
                                                        __typename?: 'SCMId';
                                                    } & Pick<ScmId, 'login'>
                                                >;
                                                images?: Maybe<
                                                    Array<
                                                        Maybe<
                                                            {
                                                                __typename?: 'DockerImage';
                                                            } & Pick<
                                                                DockerImage,
                                                                'image' | 'imageName'
                                                            >
                                                        >
                                                    >
                                                >;
                                            }
                                    >;
                                    repo?: Maybe<
                                        {
                                            __typename?: 'Repo';
                                        } & Pick<Repo, 'name' | 'owner'> & {
                                                org?: Maybe<
                                                    {
                                                        __typename?: 'Org';
                                                    } & {
                                                        provider?: Maybe<
                                                            {
                                                                __typename?: 'GitHubProvider';
                                                            } & Pick<
                                                                GitHubProvider,
                                                                'providerId'
                                                            >
                                                        >;
                                                    }
                                                >;
                                            }
                                    >;
                                    commits?: Maybe<
                                        Array<
                                            Maybe<
                                                {
                                                    __typename?: 'Commit';
                                                } & Pick<
                                                    Commit,
                                                    'sha' | 'timestamp' | 'message'
                                                > & {
                                                        author?: Maybe<
                                                            {
                                                                __typename?: 'SCMId';
                                                            } & Pick<
                                                                ScmId,
                                                                'login' | 'name'
                                                            >
                                                        >;
                                                    }
                                            >
                                        >
                                    >;
                                }
                        >;
                        repo?: Maybe<
                            {
                                __typename?: 'SdmRepository';
                            } & Pick<SdmRepository, 'name' | 'owner' | 'providerId'>
                        >;
                        fulfillment?: Maybe<
                            {
                                __typename?: 'SdmGoalFulfillment';
                            } & Pick<
                                SdmGoalFulfillment,
                                'method' | 'name' | 'registration'
                            >
                        >;
                        descriptions?: Maybe<
                            {
                                __typename?: 'SdmGoalDescriptions';
                            } & Pick<
                                SdmGoalDescriptions,
                                | 'canceled'
                                | 'completed'
                                | 'failed'
                                | 'inProcess'
                                | 'requested'
                                | 'skipped'
                                | 'stopped'
                                | 'waitingForApproval'
                                | 'waitingForPreApproval'
                            >
                        >;
                        provenance?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'SdmProvenance';
                                    } & Pick<
                                        SdmProvenance,
                                        | 'correlationId'
                                        | 'registration'
                                        | 'name'
                                        | 'version'
                                        | 'ts'
                                        | 'userId'
                                        | 'channelId'
                                    >
                                >
                            >
                        >;
                        preConditions?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'SdmCondition';
                                    } & Pick<SdmCondition, 'environment' | 'name'>
                                >
                            >
                        >;
                        preApproval?: Maybe<
                            {
                                __typename?: 'SdmProvenance';
                            } & Pick<
                                SdmProvenance,
                                | 'correlationId'
                                | 'registration'
                                | 'name'
                                | 'version'
                                | 'ts'
                                | 'userId'
                                | 'channelId'
                            >
                        >;
                    }
            >
        >
    >;
};

type KubernetesDeployRequestedSdmGoalSubscriptionVariables

type KubernetesDeployRequestedSdmGoalSubscriptionVariables = {
    fulfillmentName: Scalars['String'];
};

type Label

type Label = {
    __typename?: 'Label';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** the url of the Label */
    url?: Maybe<Scalars['String']>;
    /** id of  Label */
    id?: Maybe<Scalars['ID']>;
    /** name of  Label */
    name?: Maybe<Scalars['String']>;
    /** default of  Label */
    default?: Maybe<Scalars['String']>;
    /** color of  Label */
    color?: Maybe<Scalars['String']>;
    /** Label repo Repo */
    repo?: Maybe<Repo>;
};

Label-Node

type LabelRepoArgs

type LabelRepoArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    allowRebaseMerge?: Maybe<Scalars['Boolean']>;
    allowSquashMerge?: Maybe<Scalars['Boolean']>;
    allowMergeCommit?: Maybe<Scalars['Boolean']>;
    repoId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    defaultBranch?: Maybe<Scalars['String']>;
};

Label-Node

type LastEndpointQuery

type LastEndpointQuery = {
    __typename?: 'Query';
} & {
    Repo?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Repo';
                } & {
                    branches?: Maybe<
                        Array<
                            Maybe<
                                {
                                    __typename?: 'Branch';
                                } & {
                                    commit?: Maybe<
                                        {
                                            __typename?: 'Commit';
                                        } & Pick<Commit, 'sha'> & {
                                                statuses?: Maybe<
                                                    Array<
                                                        Maybe<
                                                            {
                                                                __typename?: 'Status';
                                                            } & Pick<
                                                                Status,
                                                                | 'context'
                                                                | 'description'
                                                                | 'state'
                                                                | 'targetUrl'
                                                            >
                                                        >
                                                    >
                                                >;
                                                pushes?: Maybe<
                                                    Array<
                                                        Maybe<
                                                            {
                                                                __typename?: 'Push';
                                                            } & Pick<Push, 'id'>
                                                        >
                                                    >
                                                >;
                                            }
                                    >;
                                }
                            >
                        >
                    >;
                }
            >
        >
    >;
};

type LastEndpointQueryVariables

type LastEndpointQueryVariables = {
    name: Scalars['String'];
    owner: Scalars['String'];
    branch: Scalars['String'];
    statusContext: Scalars['String'];
};

type LifecycleAttachment

type LifecycleAttachment = {
    __typename?: 'LifecycleAttachment';
    body?: Maybe<Scalars['String']>;
    configuration?: Maybe<Scalars['String']>;
    contentType?: Maybe<Scalars['String']>;
    identifier?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    skill?: Maybe<Scalars['String']>;
    ts?: Maybe<Scalars['Int']>;
    type?: Maybe<LifecycleAttachmentType>;
    /** The ID of this LifecycleAttachment */
    id?: Maybe<Scalars['ID']>;
};

type ListenerInvocation

type ListenerInvocation = SdmContext;

type MachineOrMachineOptions

type MachineOrMachineOptions =
    | MachineConfiguration<any>
    | SoftwareDeliveryMachineOptions;

type ManageSubscriptionPolicyLog

type ManageSubscriptionPolicyLog = {
    __typename?: 'ManageSubscriptionPolicyLog';
    action?: Maybe<ManageSubscriptionPolicyAction>;
    author?: Maybe<Scalars['String']>;
    branch?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    reason?: Maybe<Scalars['String']>;
    repo?: Maybe<Scalars['String']>;
    streamId?: Maybe<Scalars['ID']>;
    streamName?: Maybe<Scalars['String']>;
    targetSha?: Maybe<Scalars['String']>;
    targetValue?: Maybe<Scalars['String']>;
};

type ManageTargetPolicyLog

type ManageTargetPolicyLog = {
    __typename?: 'ManageTargetPolicyLog';
    action?: Maybe<ManageTargetPolicyAction>;
    author?: Maybe<Scalars['String']>;
    reason?: Maybe<Scalars['String']>;
    streamId?: Maybe<Scalars['ID']>;
    streamName?: Maybe<Scalars['String']>;
    targetSha?: Maybe<Scalars['String']>;
    targetValue?: Maybe<Scalars['String']>;
};

type MappedParameterOrSecretObjectValue

type MappedParameterOrSecretObjectValue = MappedParameterOrSecretDeclaration;

type Mapper

type Mapper<F, V> = (from: F) => MappingResult<V>;

Mapping function from F to V

type MappingResult

type MappingResult<V> = Promise<V | undefined | NeverMatch>;

Result of a Mapper. A result of the desired type if we match. undefined if we don't match. Return DoNotSetAnyGoals (null) to shortcut evaluation of the present set of rules, terminating evaluation and guarantee the return of undefined if we've reached this point. Only do so if you are sure

type MavenDependency

type MavenDependency = SourceFingerprint & {
    __typename?: 'MavenDependency';
    artifact: Scalars['String'];
    data?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    displayType?: Maybe<Scalars['String']>;
    displayValue?: Maybe<Scalars['String']>;
    group: Scalars['String'];
    id: Scalars['ID'];
    name: Scalars['String'];
    sha: Scalars['String'];
    type: Scalars['String'];
    version: Scalars['String'];
};

type MavenRepositoryProvider

type MavenRepositoryProvider = {
    _id: Scalars['Int'];
    id: Scalars['ID'];
    url: Scalars['String'];
    name: Scalars['String'];
    timestamp: Scalars['String'];
    credential?: Maybe<Credential>;
    team: Team;
};

type Maybe

type Maybe<T> = T | null;

type Mod

type Mod = 'added' | 'deleted' | 'modified' | 'renamed';

type Mutation

type Mutation = {
    __typename?: 'Mutation';
    publishSkill?: Maybe<RegisteredAtomistSkill>;
    registerSkill?: Maybe<RegisteredAtomistSkill>;
    removeSkillConfiguration?: Maybe<AtomistSkills>;
    saveSkillConfiguration?: Maybe<AtomistSkills>;
    setSkillMaturity?: Maybe<RegisteredAtomistSkill>;
    unpublishSkill?: Maybe<RegisteredAtomistSkill>;
    /** # Team/Workspace configuration ## */
    setTeamConfiguration: TeamConfiguration;
    deleteTeamConfiguration?: Maybe<TeamConfiguration>;
    disableRegistration?: Maybe<AtomistRegistration>;
    enableRegistration?: Maybe<AtomistRegistration>;
    createGHEAppResourceProvider: GitHubAppResourceProvider;
    createGitHubComAppResourceProvider: GitHubAppResourceProvider;
    /** Creates SCMProvider for github.com with a bunch of defaults */
    createGitHubResourceProvider: ScmProvider;
    createGHEResourceProvider: ScmProvider;
    createBitBucketResourceProvider: ScmProvider;
    createGitLabResourceProvider: ScmProvider;
    /** configure repos/orgs - raise system event for SCMProvider */
    configureGitHubResourceProvider: ScmProvider;
    setSCMProviderState: ScmProvider;
    /** Links a GitHubAppInstallation to the provider as an Org */
    linkGitHubAppInstallation: GitHubAppInstallation;
    createGitHubAppInstallation: GitHubAppInstallation;
    disconnectGitHubAppOrg: Scalars['String'];
    deleteOrg: Scalars['String'];
    deleteRepo: Scalars['String'];
    deleteAllFingerprints: Scalars['String'];
    deleteAspectFingerprints: Scalars['String'];
    /** create and expose a webhook over the public internet */
    createWebhook: Webhook;
    /** delete a webhook from public internet */
    deleteWebhook: Scalars['String'];
    /** associate some state with a webhook to help convergence etc */
    updateWebhook: Webhook;
    /** add (or overwrite) a tag on a webhook */
    addWebhookTag: Webhook;
    setWebhookTags: Webhook;
    /** Removes a ChatTeam and associated nodes from the graph */
    removeChatTeam: Scalars['String'];
    /** ### RCCA SCM Ingestion Mutations #### */
    ingestSCMOrgs: Array<Maybe<Org>>;
    ingestSCMRepos: Array<Maybe<Repo>>;
    ingestSCMCommit: Commit;
    setSCMOrgInitializationState?: Maybe<Org>;
    ingestChatChannels: Array<ChatChannel>;
    removeChatChannels: Scalars['String'];
    ingestChatIds: Array<ChatId>;
    removeChatIds: Scalars['String'];
    /** Deprecated. Creates a new docker registry provider. */
    createDockerRegistryProvider: DockerRegistryProvider;
    createDockerHubRegistryProvider: DockerHubRegistryProvider;
    updateDockerHubRegistryProvider: DockerHubRegistryProvider;
    createGoogleContainerRegistryProvider: GoogleContainerRegistryProvider;
    updateGoogleContainerRegistryProvider: GoogleContainerRegistryProvider;
    createJFrogDockerRegistryProvider: JFrogDockerRegistryProvider;
    updateJFrogDockerRegistryProvider: JFrogDockerRegistryProvider;
    createDockerContainerImage: DockerRegistryImage;
    createGoogleCloudPlatformProvider: GoogleCloudPlatformProvider;
    updateGoogleCloudPlatformProvider: GoogleCloudPlatformProvider;
    createKubernetesClusterProvider: KubernetesClusterProvider;
    updateKubernetesClusterProvider: KubernetesClusterProvider;
    createArtifactoryMavenRepositoryProvider: ArtifactoryMavenRepositoryProvider;
    updateArtifactoryMavenRepositoryProvider: ArtifactoryMavenRepositoryProvider;
    createNpmJSRegistryProvider: NpmJsRegistryProvider;
    updateNpmJSRegistryProvider: NpmJsRegistryProvider;
    createGitHubNpmRegistryProvider: GitHubNpmRegistryProvider;
    updateGitHubNpmRegistryProvider: GitHubNpmRegistryProvider;
    linkResourceToGraph: Resource;
    setResourceProviderState: ResourceProvider;
    deleteResourceProvider: Scalars['String'];
    setCredential: Credential;
    linkCredentialToResourceProvider: Credential;
    /** ### Users #### */
    createResourceUser?: Maybe<ResourceUser>;
    updateResourceUser?: Maybe<ResourceUser>;
    linkResourceUser?: Maybe<ResourceUser>;
    createGenericResourceProvider: GenericResourceProvider;
    createBinaryRepositoryProvider?: Maybe<BinaryRepositoryProvider>;
    createSecretProvider: SecretProvider;
    updateSecretProvider: SecretProvider;
    /** Delete all fingerprints for this team matching supplied query */
    deleteFingerprints: Scalars['Int'];
    /** Set the fingerprints of a commit */
    setCommitFingerprints?: Maybe<Scalars['String']>;
    setFingerprintTarget?: Maybe<FingerprintTarget>;
    /** Add tasks to existing job, provided the job is in a preparing state. */
    addAtmJobTasks?: Maybe<AtmJob>;
    /** Create a new AtmJob */
    createAtmJob?: Maybe<AtmJob>;
    /** Re-trigger tasks for a job that have not completed */
    resumeAtmJob?: Maybe<AtmJob>;
    /** Set the state on a AtmJobTask */
    setAtmJobTaskState?: Maybe<AtmJobTask>;
    /** Take tasks to work on */
    takeTasks: Array<Maybe<AtmJobTask>>;
    linkSlackChannelToRepo?: Maybe<ChannelLinked>;
    unlinkSlackChannelFromRepo?: Maybe<ChannelLinked>;
    /** Auto-generated ingestion mutation for Card */
    ingestCustomCard?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for Notification */
    ingestCustomNotification?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for CommitIssueRelationship */
    ingestCustomCommitIssueRelationship?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for Deployment */
    ingestCustomDeployment?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for IssueRelationship */
    ingestCustomIssueRelationship?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for SdmGoal */
    ingestCustomSdmGoal?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for SdmGoalSet */
    ingestCustomSdmGoalSet?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for SdmGoalDisplay */
    ingestCustomSdmGoalDisplay?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for SdmBuildIdentifier */
    ingestCustomSdmBuildIdentifier?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for SdmDeployEnablement */
    ingestCustomSdmDeployEnablement?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for SdmVersion */
    ingestCustomSdmVersion?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for SdmGoalSetBadge */
    ingestCustomSdmGoalSetBadge?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for SdmPreference */
    ingestCustomSdmPreference?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for SdmRepoProvenance */
    ingestCustomSdmRepoProvenance?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for PolicyLog */
    ingestCustomPolicyLog?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for PolicyCompliance */
    ingestCustomPolicyCompliance?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for PolicyTargetStream */
    ingestCustomPolicyTargetStream?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for PolicyTarget */
    ingestCustomPolicyTarget?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for LifecycleAttachment */
    ingestCustomLifecycleAttachment?: Maybe<Scalars['String']>;
    /** Auto-generated ingestion mutation for AspectRegistration */
    ingestCustomAspectRegistration?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for Card */
    deleteCustomCard?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for Notification */
    deleteCustomNotification?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for CommitIssueRelationship */
    deleteCustomCommitIssueRelationship?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for Deployment */
    deleteCustomDeployment?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for IssueRelationship */
    deleteCustomIssueRelationship?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for SdmGoal */
    deleteCustomSdmGoal?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for SdmGoalSet */
    deleteCustomSdmGoalSet?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for SdmGoalDisplay */
    deleteCustomSdmGoalDisplay?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for SdmBuildIdentifier */
    deleteCustomSdmBuildIdentifier?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for SdmDeployEnablement */
    deleteCustomSdmDeployEnablement?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for SdmVersion */
    deleteCustomSdmVersion?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for SdmGoalSetBadge */
    deleteCustomSdmGoalSetBadge?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for SdmPreference */
    deleteCustomSdmPreference?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for SdmRepoProvenance */
    deleteCustomSdmRepoProvenance?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for PolicyLog */
    deleteCustomPolicyLog?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for PolicyCompliance */
    deleteCustomPolicyCompliance?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for PolicyTargetStream */
    deleteCustomPolicyTargetStream?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for PolicyTarget */
    deleteCustomPolicyTarget?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for LifecycleAttachment */
    deleteCustomLifecycleAttachment?: Maybe<Scalars['String']>;
    /** Auto-generated deletion mutation for AspectRegistration */
    deleteCustomAspectRegistration?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for Card */
    deleteCustomCardById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for Notification */
    deleteCustomNotificationById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for CommitIssueRelationship */
    deleteCustomCommitIssueRelationshipById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for Deployment */
    deleteCustomDeploymentById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for IssueRelationship */
    deleteCustomIssueRelationshipById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for SdmGoal */
    deleteCustomSdmGoalById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for SdmGoalSet */
    deleteCustomSdmGoalSetById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for SdmGoalDisplay */
    deleteCustomSdmGoalDisplayById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for SdmBuildIdentifier */
    deleteCustomSdmBuildIdentifierById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for SdmDeployEnablement */
    deleteCustomSdmDeployEnablementById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for SdmVersion */
    deleteCustomSdmVersionById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for SdmGoalSetBadge */
    deleteCustomSdmGoalSetBadgeById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for SdmPreference */
    deleteCustomSdmPreferenceById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for SdmRepoProvenance */
    deleteCustomSdmRepoProvenanceById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for PolicyLog */
    deleteCustomPolicyLogById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for PolicyCompliance */
    deleteCustomPolicyComplianceById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for PolicyTargetStream */
    deleteCustomPolicyTargetStreamById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for PolicyTarget */
    deleteCustomPolicyTargetById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for LifecycleAttachment */
    deleteCustomLifecycleAttachmentById?: Maybe<Scalars['String']>;
    /** Auto-generated delete-by-id mutation for AspectRegistration */
    deleteCustomAspectRegistrationById?: Maybe<Scalars['String']>;
    /** Set the value of a user preference. */
    setChatUserPreference?: Maybe<Array<Maybe<UserPreference>>>;
    /** Set the value of a chat team preference. Returns what was set */
    setChatTeamPreference?: Maybe<Array<Maybe<TeamPreference>>>;
    /** Create a slack channel in the current team */
    createSlackChannel?: Maybe<SlackChannel>;
    /** Ask the bot to join a chat channel */
    addBotToSlackChannel?: Maybe<SlackChannel>;
    /** Ask the bot to invite a user to join a chat channel */
    inviteUserToSlackChannel?: Maybe<SlackChannel>;
    /** Ask the bot to kick a user from a chat channel */
    kickUserFromSlackChannel?: Maybe<SlackChannel>;
    /** set a GitHub login to be used for resources owned by an Org */
    setOwnerLogin?: Maybe<OwnerLogin>;
    /** set a GitHub login to be used for this Repository */
    setRepoLogin?: Maybe<RepoLogin>;
    /** Set a team's properties */
    setTeamProperties?: Maybe<Team>;
};

type MutationAddAtmJobTasksArgs

type MutationAddAtmJobTasksArgs = {
    jobId: Scalars['String'];
    jobTasks: Array<AtmJobTaskInput>;
};

type MutationAddBotToSlackChannelArgs

type MutationAddBotToSlackChannelArgs = {
    chatTeamId?: Maybe<Scalars['String']>;
    channelId?: Maybe<Scalars['String']>;
};

type MutationAddWebhookTagArgs

type MutationAddWebhookTagArgs = {
    id: Scalars['ID'];
    name: Scalars['String'];
    value: Scalars['String'];
};

type MutationConfigureGitHubResourceProviderArgs

type MutationConfigureGitHubResourceProviderArgs = {
    id: Scalars['ID'];
    config: ScmResourceProviderInput;
};

type MutationCreateArtifactoryMavenRepositoryProviderArgs

type MutationCreateArtifactoryMavenRepositoryProviderArgs = {
    input: ArtifactoryMavenRepositoryInput;
};

type MutationCreateAtmJobArgs

type MutationCreateAtmJobArgs = {
    jobInput: AtmJobInput;
};

type MutationCreateBinaryRepositoryProviderArgs

type MutationCreateBinaryRepositoryProviderArgs = {
    name: Scalars['String'];
    type: BinaryRepositoryType;
    url?: Maybe<Scalars['String']>;
};

type MutationCreateBitBucketResourceProviderArgs

type MutationCreateBitBucketResourceProviderArgs = {
    name: Scalars['String'];
    url: Scalars['String'];
    apiUrl: Scalars['String'];
    gitUrl: Scalars['String'];
    authProviderId?: Maybe<Scalars['String']>;
    private: Scalars['Boolean'];
};

type MutationCreateDockerContainerImageArgs

type MutationCreateDockerContainerImageArgs = {
    resourceProviderId: Scalars['ID'];
    input: DockerRegistryImageInput;
    links?: Maybe<Array<ResourceLinks>>;
};

type MutationCreateDockerHubRegistryProviderArgs

type MutationCreateDockerHubRegistryProviderArgs = {
    input: DockerHubInput;
};

type MutationCreateDockerRegistryProviderArgs

type MutationCreateDockerRegistryProviderArgs = {
    type: DockerRegistryType;
    name: Scalars['String'];
    url?: Maybe<Scalars['String']>;
};

type MutationCreateGenericResourceProviderArgs

type MutationCreateGenericResourceProviderArgs = {
    type: Scalars['String'];
    name: Scalars['String'];
    url?: Maybe<Scalars['String']>;
};

type MutationCreateGheAppResourceProviderArgs

type MutationCreateGheAppResourceProviderArgs = {
    name: Scalars['String'];
    url: Scalars['String'];
    authProviderId?: Maybe<Scalars['String']>;
    apiUrl: Scalars['String'];
    gitUrl: Scalars['String'];
    private: Scalars['Boolean'];
    applicationId: Scalars['Int'];
    applicationName: Scalars['String'];
};

type MutationCreateGheResourceProviderArgs

type MutationCreateGheResourceProviderArgs = {
    name: Scalars['String'];
    url: Scalars['String'];
    apiUrl: Scalars['String'];
    gitUrl: Scalars['String'];
    authProviderId?: Maybe<Scalars['String']>;
    private: Scalars['Boolean'];
};

type MutationCreateGitHubAppInstallationArgs

type MutationCreateGitHubAppInstallationArgs = {
    resourceProviderId: Scalars['ID'];
    installationId: Scalars['Int'];
};

type MutationCreateGitHubComAppResourceProviderArgs

type MutationCreateGitHubComAppResourceProviderArgs = {
    name: Scalars['String'];
};

type MutationCreateGitHubNpmRegistryProviderArgs

type MutationCreateGitHubNpmRegistryProviderArgs = {
    input: GitHubNpmRegistryProviderInput;
    gitHubAppInstallationId: Scalars['ID'];
};

type MutationCreateGitLabResourceProviderArgs

type MutationCreateGitLabResourceProviderArgs = {
    name: Scalars['String'];
    url: Scalars['String'];
    apiUrl: Scalars['String'];
    gitUrl: Scalars['String'];
    authProviderId?: Maybe<Scalars['String']>;
    private: Scalars['Boolean'];
};

type MutationCreateGoogleCloudPlatformProviderArgs

type MutationCreateGoogleCloudPlatformProviderArgs = {
    input: GoogleCloudPlatformInput;
};

type MutationCreateGoogleContainerRegistryProviderArgs

type MutationCreateGoogleContainerRegistryProviderArgs = {
    input: GoogleContainerRegistryInput;
};

type MutationCreateJFrogDockerRegistryProviderArgs

type MutationCreateJFrogDockerRegistryProviderArgs = {
    input: JFrogDockerRegistryInput;
};

type MutationCreateKubernetesClusterProviderArgs

type MutationCreateKubernetesClusterProviderArgs = {
    input: KubernetesClusterInput;
};

type MutationCreateNpmJsRegistryProviderArgs

type MutationCreateNpmJsRegistryProviderArgs = {
    input: NpmJsRegistryProviderInput;
};

type MutationCreateResourceUserArgs

type MutationCreateResourceUserArgs = {
    login: Scalars['String'];
    resourceProviderId: Scalars['ID'];
    resourceUserType: ResourceUserType;
};

type MutationCreateSecretProviderArgs

type MutationCreateSecretProviderArgs = {
    input: SecretProviderInput;
};

type MutationCreateSlackChannelArgs

type MutationCreateSlackChannelArgs = {
    chatTeamId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
};

type MutationCreateWebhookArgs

type MutationCreateWebhookArgs = {
    webhook: WebhookInput;
};

type MutationDeleteAspectFingerprintsArgs

type MutationDeleteAspectFingerprintsArgs = {
    featureName: Scalars['String'];
};

type MutationDeleteCustomAspectRegistrationArgs

type MutationDeleteCustomAspectRegistrationArgs = {
    value: CustomAspectRegistrationInput;
};

type MutationDeleteCustomAspectRegistrationByIdArgs

type MutationDeleteCustomAspectRegistrationByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomCardArgs

type MutationDeleteCustomCardArgs = {
    value: CustomCardInput;
};

type MutationDeleteCustomCardByIdArgs

type MutationDeleteCustomCardByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomCommitIssueRelationshipArgs

type MutationDeleteCustomCommitIssueRelationshipArgs = {
    value: CustomCommitIssueRelationshipInput;
};

type MutationDeleteCustomCommitIssueRelationshipByIdArgs

type MutationDeleteCustomCommitIssueRelationshipByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomDeploymentArgs

type MutationDeleteCustomDeploymentArgs = {
    value: CustomDeploymentInput;
};

type MutationDeleteCustomDeploymentByIdArgs

type MutationDeleteCustomDeploymentByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomIssueRelationshipArgs

type MutationDeleteCustomIssueRelationshipArgs = {
    value: CustomIssueRelationshipInput;
};

type MutationDeleteCustomIssueRelationshipByIdArgs

type MutationDeleteCustomIssueRelationshipByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomLifecycleAttachmentArgs

type MutationDeleteCustomLifecycleAttachmentArgs = {
    value: CustomLifecycleAttachmentInput;
};

type MutationDeleteCustomLifecycleAttachmentByIdArgs

type MutationDeleteCustomLifecycleAttachmentByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomNotificationArgs

type MutationDeleteCustomNotificationArgs = {
    value: CustomNotificationInput;
};

type MutationDeleteCustomNotificationByIdArgs

type MutationDeleteCustomNotificationByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomPolicyComplianceArgs

type MutationDeleteCustomPolicyComplianceArgs = {
    value: CustomPolicyComplianceInput;
};

type MutationDeleteCustomPolicyComplianceByIdArgs

type MutationDeleteCustomPolicyComplianceByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomPolicyLogArgs

type MutationDeleteCustomPolicyLogArgs = {
    value: CustomPolicyLogInput;
};

type MutationDeleteCustomPolicyLogByIdArgs

type MutationDeleteCustomPolicyLogByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomPolicyTargetArgs

type MutationDeleteCustomPolicyTargetArgs = {
    value: CustomPolicyTargetInput;
};

type MutationDeleteCustomPolicyTargetByIdArgs

type MutationDeleteCustomPolicyTargetByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomPolicyTargetStreamArgs

type MutationDeleteCustomPolicyTargetStreamArgs = {
    value: CustomPolicyTargetStreamInput;
};

type MutationDeleteCustomPolicyTargetStreamByIdArgs

type MutationDeleteCustomPolicyTargetStreamByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomSdmBuildIdentifierArgs

type MutationDeleteCustomSdmBuildIdentifierArgs = {
    value: CustomSdmBuildIdentifierInput;
};

type MutationDeleteCustomSdmBuildIdentifierByIdArgs

type MutationDeleteCustomSdmBuildIdentifierByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomSdmDeployEnablementArgs

type MutationDeleteCustomSdmDeployEnablementArgs = {
    value: CustomSdmDeployEnablementInput;
};

type MutationDeleteCustomSdmDeployEnablementByIdArgs

type MutationDeleteCustomSdmDeployEnablementByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomSdmGoalArgs

type MutationDeleteCustomSdmGoalArgs = {
    value: CustomSdmGoalInput;
};

type MutationDeleteCustomSdmGoalByIdArgs

type MutationDeleteCustomSdmGoalByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomSdmGoalDisplayArgs

type MutationDeleteCustomSdmGoalDisplayArgs = {
    value: CustomSdmGoalDisplayInput;
};

type MutationDeleteCustomSdmGoalDisplayByIdArgs

type MutationDeleteCustomSdmGoalDisplayByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomSdmGoalSetArgs

type MutationDeleteCustomSdmGoalSetArgs = {
    value: CustomSdmGoalSetInput;
};

type MutationDeleteCustomSdmGoalSetBadgeArgs

type MutationDeleteCustomSdmGoalSetBadgeArgs = {
    value: CustomSdmGoalSetBadgeInput;
};

type MutationDeleteCustomSdmGoalSetBadgeByIdArgs

type MutationDeleteCustomSdmGoalSetBadgeByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomSdmGoalSetByIdArgs

type MutationDeleteCustomSdmGoalSetByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomSdmPreferenceArgs

type MutationDeleteCustomSdmPreferenceArgs = {
    value: CustomSdmPreferenceInput;
};

type MutationDeleteCustomSdmPreferenceByIdArgs

type MutationDeleteCustomSdmPreferenceByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomSdmRepoProvenanceArgs

type MutationDeleteCustomSdmRepoProvenanceArgs = {
    value: CustomSdmRepoProvenanceInput;
};

type MutationDeleteCustomSdmRepoProvenanceByIdArgs

type MutationDeleteCustomSdmRepoProvenanceByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteCustomSdmVersionArgs

type MutationDeleteCustomSdmVersionArgs = {
    value: CustomSdmVersionInput;
};

type MutationDeleteCustomSdmVersionByIdArgs

type MutationDeleteCustomSdmVersionByIdArgs = {
    id: Scalars['ID'];
};

type MutationDeleteFingerprintsArgs

type MutationDeleteFingerprintsArgs = {
    branchId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    repoId?: Maybe<Scalars['String']>;
    type?: Maybe<Scalars['String']>;
};

type MutationDeleteOrgArgs

type MutationDeleteOrgArgs = {
    id: Scalars['ID'];
};

type MutationDeleteRepoArgs

type MutationDeleteRepoArgs = {
    id: Scalars['ID'];
};

type MutationDeleteResourceProviderArgs

type MutationDeleteResourceProviderArgs = {
    id: Scalars['ID'];
};

type MutationDeleteTeamConfigurationArgs

type MutationDeleteTeamConfigurationArgs = {
    namespace: Scalars['String'];
    name: Scalars['String'];
};

type MutationDeleteWebhookArgs

type MutationDeleteWebhookArgs = {
    id: Scalars['ID'];
};

type MutationDisableRegistrationArgs

type MutationDisableRegistrationArgs = {
    name: Scalars['String'];
};

type MutationDisconnectGitHubAppOrgArgs

type MutationDisconnectGitHubAppOrgArgs = {
    id: Scalars['ID'];
};

type MutationEnableRegistrationArgs

type MutationEnableRegistrationArgs = {
    name: Scalars['String'];
};

type MutationIngestChatChannelsArgs

type MutationIngestChatChannelsArgs = {
    chatTeamAtomistId: Scalars['ID'];
    chatChannels: Array<ChatChannelInput>;
};

type MutationIngestChatIdsArgs

type MutationIngestChatIdsArgs = {
    chatTeamAtomistId: Scalars['ID'];
    chatIds: Array<ChatIdInput>;
};

type MutationIngestCustomAspectRegistrationArgs

type MutationIngestCustomAspectRegistrationArgs = {
    value: CustomAspectRegistrationInput;
};

type MutationIngestCustomCardArgs

type MutationIngestCustomCardArgs = {
    value: CustomCardInput;
};

type MutationIngestCustomCommitIssueRelationshipArgs

type MutationIngestCustomCommitIssueRelationshipArgs = {
    value: CustomCommitIssueRelationshipInput;
};

type MutationIngestCustomDeploymentArgs

type MutationIngestCustomDeploymentArgs = {
    value: CustomDeploymentInput;
};

type MutationIngestCustomIssueRelationshipArgs

type MutationIngestCustomIssueRelationshipArgs = {
    value: CustomIssueRelationshipInput;
};

type MutationIngestCustomLifecycleAttachmentArgs

type MutationIngestCustomLifecycleAttachmentArgs = {
    value: CustomLifecycleAttachmentInput;
};

type MutationIngestCustomNotificationArgs

type MutationIngestCustomNotificationArgs = {
    value: CustomNotificationInput;
};

type MutationIngestCustomPolicyComplianceArgs

type MutationIngestCustomPolicyComplianceArgs = {
    value: CustomPolicyComplianceInput;
};

type MutationIngestCustomPolicyLogArgs

type MutationIngestCustomPolicyLogArgs = {
    value: CustomPolicyLogInput;
};

type MutationIngestCustomPolicyTargetArgs

type MutationIngestCustomPolicyTargetArgs = {
    value: CustomPolicyTargetInput;
};

type MutationIngestCustomPolicyTargetStreamArgs

type MutationIngestCustomPolicyTargetStreamArgs = {
    value: CustomPolicyTargetStreamInput;
};

type MutationIngestCustomSdmBuildIdentifierArgs

type MutationIngestCustomSdmBuildIdentifierArgs = {
    value: CustomSdmBuildIdentifierInput;
};

type MutationIngestCustomSdmDeployEnablementArgs

type MutationIngestCustomSdmDeployEnablementArgs = {
    value: CustomSdmDeployEnablementInput;
};

type MutationIngestCustomSdmGoalArgs

type MutationIngestCustomSdmGoalArgs = {
    value: CustomSdmGoalInput;
};

type MutationIngestCustomSdmGoalDisplayArgs

type MutationIngestCustomSdmGoalDisplayArgs = {
    value: CustomSdmGoalDisplayInput;
};

type MutationIngestCustomSdmGoalSetArgs

type MutationIngestCustomSdmGoalSetArgs = {
    value: CustomSdmGoalSetInput;
};

type MutationIngestCustomSdmGoalSetBadgeArgs

type MutationIngestCustomSdmGoalSetBadgeArgs = {
    value: CustomSdmGoalSetBadgeInput;
};

type MutationIngestCustomSdmPreferenceArgs

type MutationIngestCustomSdmPreferenceArgs = {
    value: CustomSdmPreferenceInput;
};

type MutationIngestCustomSdmRepoProvenanceArgs

type MutationIngestCustomSdmRepoProvenanceArgs = {
    value: CustomSdmRepoProvenanceInput;
};

type MutationIngestCustomSdmVersionArgs

type MutationIngestCustomSdmVersionArgs = {
    value: CustomSdmVersionInput;
};

type MutationIngestScmCommitArgs

type MutationIngestScmCommitArgs = {
    scmProviderId: Scalars['String'];
    scmCommitInput: ScmCommitInput;
};

type MutationIngestScmOrgsArgs

type MutationIngestScmOrgsArgs = {
    scmProviderId: Scalars['String'];
    scmOrgsInput: ScmOrgsInput;
};

type MutationIngestScmReposArgs

type MutationIngestScmReposArgs = {
    scmProviderId: Scalars['String'];
    scmReposInput: ScmReposInput;
};

type MutationInviteUserToSlackChannelArgs

type MutationInviteUserToSlackChannelArgs = {
    chatTeamId?: Maybe<Scalars['String']>;
    channelId?: Maybe<Scalars['String']>;
    userId?: Maybe<Scalars['String']>;
};

type MutationKickUserFromSlackChannelArgs

type MutationKickUserFromSlackChannelArgs = {
    chatTeamId?: Maybe<Scalars['String']>;
    channelId?: Maybe<Scalars['String']>;
    userId?: Maybe<Scalars['String']>;
};

type MutationLinkCredentialToResourceProviderArgs

type MutationLinkCredentialToResourceProviderArgs = {
    resourceProviderId: Scalars['ID'];
    credentialId: Scalars['ID'];
};

type MutationLinkGitHubAppInstallationArgs

type MutationLinkGitHubAppInstallationArgs = {
    id: Scalars['ID'];
};

type MutationLinkResourceToGraphArgs

type MutationLinkResourceToGraphArgs = {
    resourceId: Scalars['ID'];
    links?: Maybe<Array<Maybe<ResourceLinks>>>;
};

type MutationLinkResourceUserArgs

type MutationLinkResourceUserArgs = {
    resourceUserId: Scalars['ID'];
    personId: Scalars['ID'];
};

type MutationLinkSlackChannelToRepoArgs

type MutationLinkSlackChannelToRepoArgs = {
    channelId: Scalars['String'];
    channelName?: Maybe<Scalars['String']>;
    chatTeamId: Scalars['String'];
    owner: Scalars['String'];
    providerId?: Maybe<Scalars['String']>;
    repo: Scalars['String'];
};

type MutationPublishSkillArgs

type MutationPublishSkillArgs = {
    name: Scalars['String'];
    namespace: Scalars['String'];
};

type MutationRegisterSkillArgs

type MutationRegisterSkillArgs = {
    skill: AtomistSkillInput;
};

type MutationRemoveChatChannelsArgs

type MutationRemoveChatChannelsArgs = {
    chatTeamAtomistId: Scalars['ID'];
    chatChannelAtomistIds: Array<Scalars['ID']>;
};

type MutationRemoveChatIdsArgs

type MutationRemoveChatIdsArgs = {
    chatTeamAtomistId: Scalars['ID'];
    chatIdAtomistIds: Array<Scalars['ID']>;
};

type MutationRemoveChatTeamArgs

type MutationRemoveChatTeamArgs = {
    chatTeamId: Scalars['String'];
};

type MutationRemoveSkillConfigurationArgs

type MutationRemoveSkillConfigurationArgs = {
    configurationId?: Maybe<Scalars['ID']>;
    configurationName?: Maybe<Scalars['ID']>;
    name: Scalars['String'];
    namespace: Scalars['String'];
    version: Scalars['String'];
};

type MutationResumeAtmJobArgs

type MutationResumeAtmJobArgs = {
    jobId: Scalars['String'];
};

type MutationSaveSkillConfigurationArgs

type MutationSaveSkillConfigurationArgs = {
    configuration: AtomistSkillConfigurationInput;
    name: Scalars['String'];
    namespace: Scalars['String'];
    oldName?: Maybe<Scalars['ID']>;
    replacingCommitSha?: Maybe<Scalars['String']>;
    upgradePolicy?: Maybe<AtomistSkillUpgradePolicy>;
    version: Scalars['String'];
};

type MutationSetAtmJobTaskStateArgs

type MutationSetAtmJobTaskStateArgs = {
    id: Scalars['ID'];
    jobTaskState: AtmJobTaskStateInput;
};

type MutationSetChatTeamPreferenceArgs

type MutationSetChatTeamPreferenceArgs = {
    chatTeamId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
};

type MutationSetChatUserPreferenceArgs

type MutationSetChatUserPreferenceArgs = {
    chatTeamId?: Maybe<Scalars['String']>;
    chatUserId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
};

type MutationSetCommitFingerprintsArgs

type MutationSetCommitFingerprintsArgs = {
    add?: Maybe<Array<FingerprintInput>>;
    branchId: Scalars['String'];
    commitSha: Scalars['String'];
    isDefaultBranch: Scalars['Boolean'];
    isHeadCommit: Scalars['Boolean'];
    repoId: Scalars['String'];
    type: Scalars['String'];
};

type MutationSetCredentialArgs

type MutationSetCredentialArgs = {
    providerId: Scalars['ID'];
    resourceUserId: Scalars['ID'];
    credential: CredentialInput;
};

type MutationSetFingerprintTargetArgs

type MutationSetFingerprintTargetArgs = {
    target: FingerprintTargetInput;
};

type MutationSetOwnerLoginArgs

type MutationSetOwnerLoginArgs = {
    owner?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
    login?: Maybe<Scalars['String']>;
};

type MutationSetRepoLoginArgs

type MutationSetRepoLoginArgs = {
    repo?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
    login?: Maybe<Scalars['String']>;
};

type MutationSetResourceProviderStateArgs

type MutationSetResourceProviderStateArgs = {
    id: Scalars['ID'];
    providerState?: Maybe<ResourceProviderStateInput>;
};

type MutationSetScmOrgInitializationStateArgs

type MutationSetScmOrgInitializationStateArgs = {
    scmProviderId: Scalars['String'];
    scmOrgId: Scalars['String'];
    initializationState: OrgInitializationState;
};

type MutationSetScmProviderStateArgs

type MutationSetScmProviderStateArgs = {
    id: Scalars['ID'];
    providerState?: Maybe<ScmProviderStateInput>;
};

type MutationSetSkillMaturityArgs

type MutationSetSkillMaturityArgs = {
    maturity: AtomistSkillMaturityLevel;
    name: Scalars['String'];
    namespace: Scalars['String'];
    version: Scalars['String'];
};

type MutationSetTeamConfigurationArgs

type MutationSetTeamConfigurationArgs = {
    name: Scalars['String'];
    value: Scalars['String'];
    namespace?: Maybe<Scalars['String']>;
    ttlSecs?: Maybe<Scalars['Int']>;
};

type MutationSetTeamPropertiesArgs

type MutationSetTeamPropertiesArgs = {
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    iconUrl?: Maybe<Scalars['String']>;
};

type MutationSetWebhookTagsArgs

type MutationSetWebhookTagsArgs = {
    id: Scalars['ID'];
    name: Scalars['String'];
    value: Scalars['String'];
};

type MutationTakeTasksArgs

type MutationTakeTasksArgs = {
    taskRequest: AtmTaskRequest;
};

type MutationUnlinkSlackChannelFromRepoArgs

type MutationUnlinkSlackChannelFromRepoArgs = {
    channelId: Scalars['String'];
    chatTeamId: Scalars['String'];
    owner: Scalars['String'];
    providerId?: Maybe<Scalars['String']>;
    repo: Scalars['String'];
};

type MutationUnpublishSkillArgs

type MutationUnpublishSkillArgs = {
    name: Scalars['String'];
    namespace: Scalars['String'];
};

type MutationUpdateArtifactoryMavenRepositoryProviderArgs

type MutationUpdateArtifactoryMavenRepositoryProviderArgs = {
    resourceProviderId: Scalars['ID'];
    input: ArtifactoryMavenRepositoryInput;
};

type MutationUpdateDockerHubRegistryProviderArgs

type MutationUpdateDockerHubRegistryProviderArgs = {
    resourceProviderId: Scalars['ID'];
    input: DockerHubInput;
};

type MutationUpdateGitHubNpmRegistryProviderArgs

type MutationUpdateGitHubNpmRegistryProviderArgs = {
    resourceProviderId: Scalars['ID'];
    input: GitHubNpmRegistryProviderInput;
};

type MutationUpdateGoogleCloudPlatformProviderArgs

type MutationUpdateGoogleCloudPlatformProviderArgs = {
    resourceProviderId: Scalars['ID'];
    input: GoogleCloudPlatformInput;
};

type MutationUpdateGoogleContainerRegistryProviderArgs

type MutationUpdateGoogleContainerRegistryProviderArgs = {
    resourceProviderId: Scalars['ID'];
    input: GoogleContainerRegistryInput;
};

type MutationUpdateJFrogDockerRegistryProviderArgs

type MutationUpdateJFrogDockerRegistryProviderArgs = {
    resourceProviderId: Scalars['ID'];
    input: JFrogDockerRegistryInput;
};

type MutationUpdateKubernetesClusterProviderArgs

type MutationUpdateKubernetesClusterProviderArgs = {
    resourceProviderId: Scalars['ID'];
    input: KubernetesClusterInput;
};

type MutationUpdateNpmJsRegistryProviderArgs

type MutationUpdateNpmJsRegistryProviderArgs = {
    resourceProviderId: Scalars['ID'];
    input: NpmJsRegistryProviderInput;
};

type MutationUpdateResourceUserArgs

type MutationUpdateResourceUserArgs = {
    login: Scalars['String'];
    resourceUserId: Scalars['ID'];
};

type MutationUpdateSecretProviderArgs

type MutationUpdateSecretProviderArgs = {
    resourceProviderId: Scalars['ID'];
    input: SecretProviderInput;
};

type MutationUpdateWebhookArgs

type MutationUpdateWebhookArgs = {
    id: Scalars['ID'];
    webhook: WebhookUpdateInput;
};

type NamedParameter

type NamedParameter = BaseParameter & {
    name: string;
} & HasDefaultValue;

type NamedValue

type NamedValue = NamedValueParameter;

type NeverMatch

type NeverMatch = null;

type NewIssueListener

type NewIssueListener = SdmListener<NewIssueListenerInvocation>;

type Notification

type Notification = {
    __typename?: 'Notification';
    actions?: Maybe<Array<Maybe<NotificationAction>>>;
    body: Scalars['String'];
    contentType: Scalars['String'];
    correlationId: Scalars['String'];
    key: Scalars['String'];
    post?: Maybe<Scalars['String']>;
    recipient?: Maybe<NotificationRecipient>;
    ts: Scalars['Int'];
    ttl?: Maybe<Scalars['Int']>;
    /** The ID of this Notification */
    id?: Maybe<Scalars['ID']>;
};

type NotificationAction

type NotificationAction = {
    __typename?: 'NotificationAction';
    command?: Maybe<Scalars['String']>;
    parameterName?: Maybe<Scalars['String']>;
    parameterOptionGroups?: Maybe<
        Array<Maybe<NotificationActionParameterOptionGroup>>
    >;
    parameterOptions?: Maybe<Array<Maybe<NotificationActionParameterOption>>>;
    parameters?: Maybe<Array<Maybe<NotificationActionParameter>>>;
    registration?: Maybe<Scalars['String']>;
    role?: Maybe<Scalars['String']>;
    text?: Maybe<Scalars['String']>;
    type?: Maybe<Scalars['String']>;
};

type NotificationActionGroup

type NotificationActionGroup = {
    __typename?: 'NotificationActionGroup';
    actions?: Maybe<Array<Maybe<CardAction>>>;
    text?: Maybe<Scalars['String']>;
};

type NotificationActionParameter

type NotificationActionParameter = {
    __typename?: 'NotificationActionParameter';
    name?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
};

type NotificationActionParameterOption

type NotificationActionParameterOption = {
    __typename?: 'NotificationActionParameterOption';
    name?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
};

type NotificationActionParameterOptionGroup

type NotificationActionParameterOptionGroup = {
    __typename?: 'NotificationActionParameterOptionGroup';
    name?: Maybe<Scalars['String']>;
    options?: Maybe<Array<Maybe<NotificationActionParameterOption>>>;
};

type NotificationRecipient

type NotificationRecipient = {
    __typename?: 'NotificationRecipient';
    address: Scalars['String'];
};

type NotificationRecipientArgs

type NotificationRecipientArgs = {
    address?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type NpmDependency

type NpmDependency = SourceFingerprint & {
    __typename?: 'NpmDependency';
    data?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    displayType?: Maybe<Scalars['String']>;
    displayValue?: Maybe<Scalars['String']>;
    id: Scalars['ID'];
    name: Scalars['String'];
    sha: Scalars['String'];
    type: Scalars['String'];
    version: Scalars['String'];
};

type NpmJsRegistryProvider

type NpmJsRegistryProvider = ResourceProvider &
    NpmRegistryProvider & {
        __typename?: 'NpmJSRegistryProvider';
        url: Scalars['String'];
        scope?: Maybe<Scalars['String']>;
        credential?: Maybe<Credential>;
        _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
        _id: Scalars['Int'];
        id: Scalars['ID'];
        name?: Maybe<Scalars['String']>;
        team: Team;
        authProviderId?: Maybe<Scalars['String']>;
        state?: Maybe<ResourceProviderState>;
        webhooks?: Maybe<Array<Maybe<Webhook>>>;
        createdAt: Scalars['String'];
        updatedAt: Scalars['String'];
        createdBy?: Maybe<Person>;
        updatedBy?: Maybe<Person>;
        metadata?: Maybe<ResourceProviderMetadata>;
    };

type NpmJsRegistryProviderInput

type NpmJsRegistryProviderInput = {
    scope?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
};

type NpmJsRegistryProviderWebhooksArgs

type NpmJsRegistryProviderWebhooksArgs = {
    id?: Maybe<Scalars['ID']>;
};

type NpmRegistryProvider

type NpmRegistryProvider = {
    _id: Scalars['Int'];
    id: Scalars['ID'];
    team: Team;
    createdAt: Scalars['String'];
    updatedAt: Scalars['String'];
    createdBy?: Maybe<Person>;
    updatedBy?: Maybe<Person>;
    metadata?: Maybe<ResourceProviderMetadata>;
    url: Scalars['String'];
    scope?: Maybe<Scalars['String']>;
};

type OAuthInput

type OAuthInput = {
    secret: Scalars['String'];
    scopes: Array<Scalars['String']>;
};

type OAuthToken

type OAuthToken = Credential & {
    __typename?: 'OAuthToken';
    owner: ScmId;
    scopes: Array<Scalars['String']>;
    secret: Scalars['String'];
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    _id: Scalars['Int'];
    id: Scalars['ID'];
};

type Ok

type Ok = {
    __typename?: 'Ok';
    ok: Scalars['Boolean'];
};

type OnAnyApprovedSdmGoalSubscription

type OnAnyApprovedSdmGoalSubscription = {
    __typename?: 'Subscription';
} & {
    SdmGoal?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SdmGoal';
                } & SdmGoalFieldsFragment &
                    SdmGoalRepoFragment
            >
        >
    >;
};

type OnAnyApprovedSdmGoalSubscriptionVariables

type OnAnyApprovedSdmGoalSubscriptionVariables = {
    registration?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type OnAnyCompletedSdmGoalSubscription

type OnAnyCompletedSdmGoalSubscription = {
    __typename?: 'Subscription';
} & {
    SdmGoal?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SdmGoal';
                } & SdmGoalWithGoalsFieldsFragment &
                    SdmGoalRepoFragment
            >
        >
    >;
};

type OnAnyCompletedSdmGoalSubscriptionVariables

type OnAnyCompletedSdmGoalSubscriptionVariables = {
    registration?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type OnAnyFailedSdmGoalSubscription

type OnAnyFailedSdmGoalSubscription = {
    __typename?: 'Subscription';
} & {
    SdmGoal?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SdmGoal';
                } & SdmGoalWithGoalsFieldsFragment &
                    SdmGoalRepoFragment
            >
        >
    >;
};

type OnAnyFailedSdmGoalSubscriptionVariables

type OnAnyFailedSdmGoalSubscriptionVariables = {
    registration?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type OnAnyJobTaskSubscription

type OnAnyJobTaskSubscription = {
    __typename?: 'Subscription';
} & {
    AtmJobTask?: Maybe<
        Array<
            {
                __typename?: 'AtmJobTask';
            } & Pick<AtmJobTask, 'id' | 'data' | 'name' | 'state' | 'message'> & {
                    job: {
                        __typename?: 'AtmJob';
                    } & Pick<AtmJob, 'id' | 'data'>;
                }
        >
    >;
};

type OnAnyJobTaskSubscriptionVariables

type OnAnyJobTaskSubscriptionVariables = {
    registration?: Maybe<Scalars['String']>;
};

type OnAnyRequestedSdmGoalSubscription

type OnAnyRequestedSdmGoalSubscription = {
    __typename?: 'Subscription';
} & {
    SdmGoal?: Maybe<
        Array<
            Maybe<
                ({
                    __typename?: 'SdmGoal';
                } & Pick<SdmGoal, 'id'>) &
                    SdmGoalFieldsFragment &
                    SdmGoalRepoFragment
            >
        >
    >;
};

type OnAnyRequestedSdmGoalSubscriptionVariables

type OnAnyRequestedSdmGoalSubscriptionVariables = {};

type OnAnySdmGoalSetSubscription

type OnAnySdmGoalSetSubscription = {
    __typename?: 'Subscription';
} & {
    SdmGoalSet?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SdmGoalSet';
                } & Pick<
                    SdmGoalSet,
                    'sha' | 'branch' | 'goalSet' | 'goalSetId' | 'state' | 'ts'
                > & {
                        goals?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'SdmGoalName';
                                    } & Pick<SdmGoalName, 'name' | 'uniqueName'>
                                >
                            >
                        >;
                        provenance?: Maybe<
                            {
                                __typename?: 'SdmProvenance';
                            } & Pick<
                                SdmProvenance,
                                | 'channelId'
                                | 'correlationId'
                                | 'name'
                                | 'registration'
                                | 'ts'
                                | 'userId'
                                | 'version'
                            >
                        >;
                        repo?: Maybe<
                            {
                                __typename?: 'SdmRepository';
                            } & Pick<SdmRepository, 'name' | 'owner' | 'providerId'>
                        >;
                        tags?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'SdmGoalSetTag';
                                    } & Pick<SdmGoalSetTag, 'name' | 'value'>
                                >
                            >
                        >;
                    }
            >
        >
    >;
};

type OnAnySdmGoalSetSubscriptionVariables

type OnAnySdmGoalSetSubscriptionVariables = {
    registration?: Maybe<Array<Scalars['String']>>;
};

type OnAnySuccessfulSdmGoalSubscription

type OnAnySuccessfulSdmGoalSubscription = {
    __typename?: 'Subscription';
} & {
    SdmGoal?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SdmGoal';
                } & SdmGoalWithGoalsFieldsFragment &
                    SdmGoalRepoFragment
            >
        >
    >;
};

type OnAnySuccessfulSdmGoalSubscriptionVariables

type OnAnySuccessfulSdmGoalSubscriptionVariables = {
    registration?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type OnBuildCompleteForDryRunSubscription

type OnBuildCompleteForDryRunSubscription = {
    __typename?: 'Subscription';
} & {
    Build?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Build';
                } & Pick<
                    Build,
                    'buildId' | 'buildUrl' | 'compareUrl' | 'name' | 'status'
                > & {
                        commit?: Maybe<
                            {
                                __typename?: 'Commit';
                            } & Pick<Commit, 'sha' | 'message'> & {
                                    repo?: Maybe<
                                        {
                                            __typename?: 'Repo';
                                        } & CoreRepoFieldsAndChannelsFragment
                                    >;
                                    pushes?: Maybe<
                                        Array<
                                            Maybe<
                                                {
                                                    __typename?: 'Push';
                                                } & Pick<Push, 'branch'>
                                            >
                                        >
                                    >;
                                    statuses?: Maybe<
                                        Array<
                                            Maybe<
                                                {
                                                    __typename?: 'Status';
                                                } & Pick<
                                                    Status,
                                                    | 'context'
                                                    | 'description'
                                                    | 'state'
                                                    | 'targetUrl'
                                                >
                                            >
                                        >
                                    >;
                                }
                        >;
                    }
            >
        >
    >;
};

type OnBuildCompleteForDryRunSubscriptionVariables

type OnBuildCompleteForDryRunSubscriptionVariables = {};

type OnBuildCompleteSubscription

type OnBuildCompleteSubscription = {
    __typename?: 'Subscription';
} & {
    Build?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Build';
                } & Pick<
                    Build,
                    | 'buildId'
                    | 'buildUrl'
                    | 'compareUrl'
                    | 'name'
                    | 'status'
                    | 'jobId'
                    | 'startedAt'
                    | 'timestamp'
                > & {
                        push?: Maybe<
                            {
                                __typename?: 'Push';
                            } & PushFieldsFragment
                        >;
                        commit?: Maybe<
                            {
                                __typename?: 'Commit';
                            } & Pick<Commit, 'sha' | 'message' | 'timestamp'> & {
                                    repo?: Maybe<
                                        {
                                            __typename?: 'Repo';
                                        } & CoreRepoFieldsAndChannelsFragment
                                    >;
                                    statuses?: Maybe<
                                        Array<
                                            Maybe<
                                                {
                                                    __typename?: 'Status';
                                                } & Pick<
                                                    Status,
                                                    | 'context'
                                                    | 'description'
                                                    | 'state'
                                                    | 'targetUrl'
                                                >
                                            >
                                        >
                                    >;
                                }
                        >;
                    }
            >
        >
    >;
};

type OnBuildCompleteSubscriptionVariables

type OnBuildCompleteSubscriptionVariables = {};

type OnChannelLinkSubscription

type OnChannelLinkSubscription = {
    __typename?: 'Subscription';
} & {
    ChannelLink?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'ChannelLink';
                } & {
                    repo?: Maybe<
                        {
                            __typename?: 'Repo';
                        } & CoreRepoFieldsAndChannelsFragment
                    >;
                    channel?: Maybe<
                        {
                            __typename?: 'ChatChannel';
                        } & Pick<ChatChannel, 'name' | 'id'> & {
                                team?: Maybe<
                                    {
                                        __typename?: 'ChatTeam';
                                    } & Pick<ChatTeam, 'id'>
                                >;
                            }
                    >;
                }
            >
        >
    >;
};

type OnChannelLinkSubscriptionVariables

type OnChannelLinkSubscriptionVariables = {};

type OnClosedIssueSubscription

type OnClosedIssueSubscription = {
    __typename?: 'Subscription';
} & {
    Issue?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Issue';
                } & Pick<
                    Issue,
                    'number' | 'title' | 'body' | 'createdAt' | 'updatedAt'
                > & {
                        openedBy?: Maybe<
                            {
                                __typename?: 'SCMId';
                            } & Pick<ScmId, 'login'> & {
                                    person?: Maybe<
                                        {
                                            __typename?: 'Person';
                                        } & PersonFieldsFragment
                                    >;
                                }
                        >;
                        closedBy?: Maybe<
                            {
                                __typename?: 'SCMId';
                            } & Pick<ScmId, 'login'> & {
                                    person?: Maybe<
                                        {
                                            __typename?: 'Person';
                                        } & PersonFieldsFragment
                                    >;
                                }
                        >;
                        repo: {
                            __typename?: 'Repo';
                        } & CoreRepoFieldsAndChannelsFragment;
                        assignees?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'SCMId';
                                    } & Pick<ScmId, 'login'> & {
                                            person?: Maybe<
                                                {
                                                    __typename?: 'Person';
                                                } & PersonFieldsFragment
                                            >;
                                        }
                                >
                            >
                        >;
                    }
            >
        >
    >;
};

type OnClosedIssueSubscriptionVariables

type OnClosedIssueSubscriptionVariables = {};

type OnFirstPushToRepoSubscription

type OnFirstPushToRepoSubscription = {
    __typename?: 'Subscription';
} & {
    Push?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Push';
                } & PushFieldsFragment
            >
        >
    >;
};

type OnFirstPushToRepoSubscriptionVariables

type OnFirstPushToRepoSubscriptionVariables = {};

type OnIssueActionSubscription

type OnIssueActionSubscription = {
    __typename?: 'Subscription';
} & {
    Issue?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Issue';
                } & Pick<
                    Issue,
                    'number' | 'title' | 'state' | 'body' | 'createdAt' | 'updatedAt'
                > & {
                        openedBy?: Maybe<
                            {
                                __typename?: 'SCMId';
                            } & Pick<ScmId, 'login'> & {
                                    person?: Maybe<
                                        {
                                            __typename?: 'Person';
                                        } & PersonFieldsFragment
                                    >;
                                }
                        >;
                        repo: {
                            __typename?: 'Repo';
                        } & CoreRepoFieldsAndChannelsFragment;
                        assignees?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'SCMId';
                                    } & Pick<ScmId, 'login'> & {
                                            person?: Maybe<
                                                {
                                                    __typename?: 'Person';
                                                } & PersonFieldsFragment
                                            >;
                                        }
                                >
                            >
                        >;
                    }
            >
        >
    >;
};

type OnIssueActionSubscriptionVariables

type OnIssueActionSubscriptionVariables = {};

type OnNewIssueSubscription

type OnNewIssueSubscription = {
    __typename?: 'Subscription';
} & {
    Issue?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Issue';
                } & Pick<
                    Issue,
                    'number' | 'title' | 'state' | 'body' | 'createdAt' | 'updatedAt'
                > & {
                        openedBy?: Maybe<
                            {
                                __typename?: 'SCMId';
                            } & Pick<ScmId, 'login'> & {
                                    person?: Maybe<
                                        {
                                            __typename?: 'Person';
                                        } & PersonFieldsFragment
                                    >;
                                }
                        >;
                        repo: {
                            __typename?: 'Repo';
                        } & CoreRepoFieldsAndChannelsFragment;
                        assignees?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'SCMId';
                                    } & Pick<ScmId, 'login'> & {
                                            person?: Maybe<
                                                {
                                                    __typename?: 'Person';
                                                } & PersonFieldsFragment
                                            >;
                                        }
                                >
                            >
                        >;
                    }
            >
        >
    >;
};

type OnNewIssueSubscriptionVariables

type OnNewIssueSubscriptionVariables = {};

type OnPullRequestSubscription

type OnPullRequestSubscription = {
    __typename?: 'Subscription';
} & {
    PullRequest?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'PullRequest';
                } & Pick<
                    PullRequest,
                    | 'title'
                    | 'number'
                    | 'body'
                    | 'id'
                    | 'action'
                    | 'createdAt'
                    | 'updatedAt'
                    | 'mergeStatus'
                > & {
                        branch?: Maybe<
                            {
                                __typename?: 'Branch';
                            } & Pick<Branch, 'name'>
                        >;
                        base?: Maybe<
                            {
                                __typename?: 'Commit';
                            } & Pick<Commit, 'sha' | 'message'>
                        >;
                        author?: Maybe<
                            {
                                __typename?: 'SCMId';
                            } & Pick<ScmId, 'login'> & {
                                    person?: Maybe<
                                        {
                                            __typename?: 'Person';
                                        } & Pick<Person, 'name'> & {
                                                chatId?: Maybe<
                                                    {
                                                        __typename?: 'ChatId';
                                                    } & Pick<ChatId, 'screenName'>
                                                >;
                                            }
                                    >;
                                }
                        >;
                        head?: Maybe<
                            {
                                __typename?: 'Commit';
                            } & Pick<Commit, 'sha' | 'message'> & {
                                    committer?: Maybe<
                                        {
                                            __typename?: 'SCMId';
                                        } & Pick<ScmId, 'login'> & {
                                                person?: Maybe<
                                                    {
                                                        __typename?: 'Person';
                                                    } & Pick<Person, 'name'> & {
                                                            chatId?: Maybe<
                                                                {
                                                                    __typename?: 'ChatId';
                                                                } & Pick<
                                                                    ChatId,
                                                                    'screenName'
                                                                >
                                                            >;
                                                        }
                                                >;
                                            }
                                    >;
                                    pushes?: Maybe<
                                        Array<
                                            Maybe<
                                                {
                                                    __typename?: 'Push';
                                                } & Pick<Push, 'branch' | 'id'> & {
                                                        before?: Maybe<
                                                            {
                                                                __typename?: 'Commit';
                                                            } & Pick<
                                                                Commit,
                                                                'sha' | 'message'
                                                            >
                                                        >;
                                                        commits?: Maybe<
                                                            Array<
                                                                Maybe<
                                                                    {
                                                                        __typename?: 'Commit';
                                                                    } & Pick<
                                                                        Commit,
                                                                        | 'sha'
                                                                        | 'message'
                                                                    >
                                                                >
                                                            >
                                                        >;
                                                        repo?: Maybe<
                                                            {
                                                                __typename?: 'Repo';
                                                            } & CoreRepoFieldsAndChannelsFragment
                                                        >;
                                                    }
                                            >
                                        >
                                    >;
                                }
                        >;
                        repo?: Maybe<
                            {
                                __typename?: 'Repo';
                            } & CoreRepoFieldsAndChannelsFragment
                        >;
                    }
            >
        >
    >;
};

type OnPullRequestSubscriptionVariables

type OnPullRequestSubscriptionVariables = {};

type OnPushToAnyBranchSubscription

type OnPushToAnyBranchSubscription = {
    __typename?: 'Subscription';
} & {
    Push?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Push';
                } & PushFieldsFragment
            >
        >
    >;
};

type OnPushToAnyBranchSubscriptionVariables

type OnPushToAnyBranchSubscriptionVariables = {};

type OnRepoCreationSubscription

type OnRepoCreationSubscription = {
    __typename?: 'Subscription';
} & {
    Repo?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Repo';
                } & Pick<Repo, 'owner' | 'name' | 'id'>
            >
        >
    >;
};

type OnRepoCreationSubscriptionVariables

type OnRepoCreationSubscriptionVariables = {};

type OnRepoOnboardedSubscription

type OnRepoOnboardedSubscription = {
    __typename?: 'Subscription';
} & {
    RepoOnboarded?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'RepoOnboarded';
                } & {
                    repo: {
                        __typename?: 'Repo';
                    } & CoreRepoFieldsAndChannelsFragment;
                }
            >
        >
    >;
};

type OnRepoOnboardedSubscriptionVariables

type OnRepoOnboardedSubscriptionVariables = {};

type OnSchedule

type OnSchedule = {
    __typename?: 'OnSchedule';
    /** The name of the configuration that fired this event */
    configurationName: Scalars['String'];
    /** The parameterName that this schedule is associated with */
    parameterName: Scalars['String'];
};

A scheduled event for generic time-based triggering

type OnSpecificCanceledSdmGoalSubscription

type OnSpecificCanceledSdmGoalSubscription = {
    __typename?: 'Subscription';
} & {
    SdmGoal?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SdmGoal';
                } & Pick<SdmGoal, 'id' | 'uniqueName' | 'name' | 'state'>
            >
        >
    >;
};

type OnSpecificCanceledSdmGoalSubscriptionVariables

type OnSpecificCanceledSdmGoalSubscriptionVariables = {
    goalSetId: Scalars['String'];
    uniqueName: Scalars['String'];
};

type OnSuccessStatusSubscription

type OnSuccessStatusSubscription = {
    __typename?: 'Subscription';
} & {
    Status?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Status';
                } & Pick<
                    Status,
                    'state' | 'targetUrl' | 'context' | 'description'
                > & {
                        commit?: Maybe<
                            {
                                __typename?: 'Commit';
                            } & Pick<Commit, 'sha' | 'message'> & {
                                    statuses?: Maybe<
                                        Array<
                                            Maybe<
                                                {
                                                    __typename?: 'Status';
                                                } & Pick<
                                                    Status,
                                                    | 'context'
                                                    | 'description'
                                                    | 'state'
                                                >
                                            >
                                        >
                                    >;
                                    repo?: Maybe<
                                        {
                                            __typename?: 'Repo';
                                        } & CoreRepoFieldsAndChannelsFragment
                                    >;
                                    pushes?: Maybe<
                                        Array<
                                            Maybe<
                                                {
                                                    __typename?: 'Push';
                                                } & Pick<Push, 'branch'>
                                            >
                                        >
                                    >;
                                }
                        >;
                    }
            >
        >
    >;
};

type OnSuccessStatusSubscriptionVariables

type OnSuccessStatusSubscriptionVariables = {
    context: Scalars['String'];
};

type OnTagSubscription

type OnTagSubscription = {
    __typename?: 'Subscription';
} & {
    Tag?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Tag';
                } & Pick<Tag, 'id' | 'name' | 'description' | 'timestamp'> & {
                        release?: Maybe<
                            {
                                __typename?: 'Release';
                            } & Pick<Release, 'name' | 'id' | 'timestamp'>
                        >;
                        commit?: Maybe<
                            {
                                __typename?: 'Commit';
                            } & Pick<Commit, 'sha' | 'message'> & {
                                    repo?: Maybe<
                                        {
                                            __typename?: 'Repo';
                                        } & CoreRepoFieldsAndChannelsFragment
                                    >;
                                }
                        >;
                    }
            >
        >
    >;
};

type OnTagSubscriptionVariables

type OnTagSubscriptionVariables = {};

type OnUserJoiningChannelSubscription

type OnUserJoiningChannelSubscription = {
    __typename?: 'Subscription';
} & {
    UserJoinedChannel?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'UserJoinedChannel';
                } & {
                    user?: Maybe<
                        {
                            __typename?: 'ChatId';
                        } & Pick<ChatId, 'screenName'> & {
                                person?: Maybe<
                                    {
                                        __typename?: 'Person';
                                    } & PersonFieldsFragment
                                >;
                            }
                    >;
                    channel?: Maybe<
                        {
                            __typename?: 'ChatChannel';
                        } & Pick<ChatChannel, 'name'> & {
                                repos?: Maybe<
                                    Array<
                                        Maybe<
                                            {
                                                __typename?: 'Repo';
                                            } & CoreRepoFieldsAndChannelsFragment
                                        >
                                    >
                                >;
                            }
                    >;
                }
            >
        >
    >;
};

type OnUserJoiningChannelSubscriptionVariables

type OnUserJoiningChannelSubscriptionVariables = {};

type Org

type Org = {
    __typename?: 'Org';
    _id?: Maybe<Scalars['Int']>;
    url?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    ownerType?: Maybe<OwnerType>;
    avatarUrl?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    initializationState?: Maybe<OrgInitializationState>;
    installation?: Maybe<GitHubAppInstallation>;
    provider?: Maybe<GitHubProvider>;
    scmProvider?: Maybe<ScmProvider>;
    repo?: Maybe<Array<Maybe<Repo>>>;
    repos?: Maybe<Array<Maybe<Repo>>>;
    chatTeam?: Maybe<ChatTeam>;
    team?: Maybe<Team>;
};

type OrgChatTeamArgs

type OrgChatTeamArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    tenantId?: Maybe<Scalars['String']>;
    domain?: Maybe<Scalars['String']>;
    messageCount?: Maybe<Scalars['Float']>;
    emailDomain?: Maybe<Scalars['String']>;
};

type OrgProviderArgs

type OrgProviderArgs = {
    id?: Maybe<Scalars['ID']>;
    url?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
    apiUrl?: Maybe<Scalars['String']>;
    gitUrl?: Maybe<Scalars['String']>;
    providerType?: Maybe<ProviderType>;
};

type OrgRepoArgs

type OrgRepoArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    allowRebaseMerge?: Maybe<Scalars['Boolean']>;
    allowSquashMerge?: Maybe<Scalars['Boolean']>;
    allowMergeCommit?: Maybe<Scalars['Boolean']>;
    repoId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    defaultBranch?: Maybe<Scalars['String']>;
};

type OrgReposArgs

type OrgReposArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    allowRebaseMerge?: Maybe<Scalars['Boolean']>;
    allowSquashMerge?: Maybe<Scalars['Boolean']>;
    allowMergeCommit?: Maybe<Scalars['Boolean']>;
    repoId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    defaultBranch?: Maybe<Scalars['String']>;
};

type OrgScmProviderArgs

type OrgScmProviderArgs = {
    id?: Maybe<Scalars['ID']>;
    url?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
    apiUrl?: Maybe<Scalars['String']>;
    gitUrl?: Maybe<Scalars['String']>;
    providerType?: Maybe<ProviderType>;
};

type OrgTeamArgs

type OrgTeamArgs = {
    id?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    iconUrl?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
};

type OwnerLogin

type OwnerLogin = {
    __typename?: 'OwnerLogin';
    /** The owner name for the Organization/Team */
    owner?: Maybe<Scalars['String']>;
    /** The id of the git provider for this Owner */
    providerId?: Maybe<Scalars['String']>;
    /** The login that should be used */
    login?: Maybe<Scalars['String']>;
};

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

type PagingInfo

type PagingInfo = {
    __typename?: 'PagingInfo';
    /** If present, indicates that there are more results */
    after?: Maybe<Scalars['String']>;
};

type PagingInfoInput

type PagingInfoInput = {
    after?: Maybe<Scalars['String']>;
};

type ParameterPrompt

type ParameterPrompt<PARAMS> = (
    parameters: ParametersPromptObject<PARAMS>,
    options?: ParameterPromptOptions
) => Promise<PARAMS>;

ParameterPrompts let the caller prompt for the provided parameters

type ParameterPromptFactory

type ParameterPromptFactory<PARAMS> = (
    ctx: HandlerContext
) => ParameterPrompt<PARAMS>;

Factory to create a ParameterPrompt

type ParametersDefinition

type ParametersDefinition<PARAMS = any> =
    | ParametersListing
    | ParametersObject<PARAMS>;

type ParametersObject

type ParametersObject<PARAMS, K extends keyof PARAMS = keyof PARAMS> = Record<
    K,
    | ParametersObjectValue
    | MappedParameterOrSecretObjectValue
    | ValueParameterObjectValue
>;

Object with properties defining parameters, secrets, mapped parameters and values. Useful for combination via spreads.

type ParametersObjectValue

type ParametersObjectValue = BaseParameter & HasDefaultValue;

type ParametersPromptObject

type ParametersPromptObject<PARAMS, K extends keyof PARAMS = keyof PARAMS> = Record<
    K,
    ParametersObjectValue & {
        force?: boolean;
    }
>;

Object with properties defining parameters. Useful for combination via spreads.

type Password

type Password = Credential & {
    __typename?: 'Password';
    owner: ResourceUser;
    secret: Scalars['String'];
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    _id: Scalars['Int'];
    id: Scalars['ID'];
};

type PasswordInput

type PasswordInput = {
    secret: Scalars['String'];
};

type PasswordQuery

type PasswordQuery = {
    __typename?: 'Query';
} & {
    Password?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Password';
                } & Pick<Password, 'secret'> & {
                        owner:
                            | ({
                                  __typename?: 'SCMId';
                              } & Pick<ScmId, 'login'>)
                            | ({
                                  __typename?: 'GitHubId';
                              } & Pick<GitHubId, 'login'>)
                            | ({
                                  __typename?: 'GitHubAppResourceUser';
                              } & Pick<GitHubAppResourceUser, 'login'>)
                            | ({
                                  __typename?: 'GenericResourceUser';
                              } & Pick<GenericResourceUser, 'login'>)
                            | ({
                                  __typename?: 'SystemAccount';
                              } & Pick<SystemAccount, 'login'>);
                    }
            >
        >
    >;
};

type PasswordQueryVariables

type PasswordQueryVariables = {
    id: Scalars['ID'];
};

type Person

type Person = {
    __typename?: 'Person';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** id of  Person */
    id?: Maybe<Scalars['ID']>;
    /** forename of  Person */
    forename?: Maybe<Scalars['String']>;
    /** surname of  Person */
    surname?: Maybe<Scalars['String']>;
    /** name of  Person */
    name?: Maybe<Scalars['String']>;
    resourceUsers?: Maybe<Array<Maybe<ResourceUser>>>;
    /** Person scmId SCMId */
    scmId?: Maybe<ScmId>;
    /** Person gitHubId GitHubId */
    gitHubId?: Maybe<GitHubId>;
    /** Person chatId ChatId */
    chatId?: Maybe<ChatId>;
    /** Person emails Email */
    emails?: Maybe<Array<Maybe<Email>>>;
    /** Person team Team */
    team?: Maybe<Team>;
};

Person-Node

type PersonByChatIdQuery

type PersonByChatIdQuery = {
    __typename?: 'Query';
} & {
    ChatId?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'ChatId';
                } & Pick<ChatId, 'userId' | 'screenName'> & {
                        person?: Maybe<
                            {
                                __typename?: 'Person';
                            } & PersonFieldsFragment
                        >;
                    }
            >
        >
    >;
};

type PersonByChatIdQueryVariables

type PersonByChatIdQueryVariables = {
    screenName: Scalars['String'];
};

type PersonChatIdArgs

type PersonChatIdArgs = {
    id?: Maybe<Scalars['ID']>;
    screenName?: Maybe<Scalars['String']>;
    userId?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    isAtomistBot?: Maybe<Scalars['String']>;
    isOwner?: Maybe<Scalars['String']>;
    isPrimaryOwner?: Maybe<Scalars['String']>;
    isAdmin?: Maybe<Scalars['String']>;
    isBot?: Maybe<Scalars['String']>;
    timezoneLabel?: Maybe<Scalars['String']>;
};

Person-Node

type PersonEmailsArgs

type PersonEmailsArgs = {
    orderBy?: Maybe<Array<Maybe<_EmailOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    address?: Maybe<Scalars['String']>;
};

Person-Node

type PersonFieldsFragment

type PersonFieldsFragment = {
    __typename?: 'Person';
} & Pick<Person, 'forename' | 'surname' | 'name'> & {
        emails?: Maybe<
            Array<
                Maybe<
                    {
                        __typename?: 'Email';
                    } & Pick<Email, 'address'>
                >
            >
        >;
        gitHubId?: Maybe<
            {
                __typename?: 'GitHubId';
            } & Pick<GitHubId, 'login'>
        >;
        chatId?: Maybe<
            {
                __typename?: 'ChatId';
            } & Pick<ChatId, 'screenName'> & {
                    chatTeam?: Maybe<
                        {
                            __typename?: 'ChatTeam';
                        } & Pick<ChatTeam, 'id'>
                    >;
                }
        >;
    };

type PersonGitHubIdArgs

type PersonGitHubIdArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
};

Person-Node

type PersonQueryQuery

type PersonQueryQuery = {
    __typename?: 'Query';
} & {
    ChatId?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'ChatId';
                } & Pick<ChatId, 'userId' | 'screenName'> & {
                        person?: Maybe<
                            {
                                __typename?: 'Person';
                            } & PersonFieldsFragment
                        >;
                    }
            >
        >
    >;
};

type PersonQueryQueryVariables

type PersonQueryQueryVariables = {
    screenName: Scalars['String'];
};

type PersonResourceUsersArgs

type PersonResourceUsersArgs = {
    login?: Maybe<Scalars['String']>;
};

Person-Node

type PersonScmIdArgs

type PersonScmIdArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    avatar?: Maybe<Scalars['String']>;
};

Person-Node

type PersonTeamArgs

type PersonTeamArgs = {
    id?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    iconUrl?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
};

Person-Node

type Pipeline

type Pipeline = {
    __typename?: 'Pipeline';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** Pipeline status */
    status?: Maybe<PipelineStatus>;
    /** Pipieline provider */
    provider?: Maybe<PipelineProvider>;
    /** Source id of the pipeline from the provider */
    pipelineId?: Maybe<Scalars['ID']>;
    /** The time this Pipeline was created */
    createdAt?: Maybe<Scalars['String']>;
    /** The time this Pipeline finished. Empty if not finished. */
    finishedAt?: Maybe<Scalars['String']>;
    /** The repo this pipeline ran against */
    repo?: Maybe<Repo>;
    /** The push that triggered this pipeline if applicable */
    push?: Maybe<Push>;
    /** The commit associated with this pipeline if applicable */
    commit?: Maybe<Commit>;
    /** The set of stages associated with this pipeline */
    stages?: Maybe<Array<Maybe<Stage>>>;
};

Pipeline-Node

type PlannedGoals

type PlannedGoals = Record<
    string,
    {
        goals: PlannedGoal | Array<PlannedGoal | PlannedGoal[]>;
        dependsOn?: string | string[];
    }
>;

type PolicyCompliance

type PolicyCompliance = {
    __typename?: 'PolicyCompliance';
    _branch?: Maybe<Scalars['String']>;
    _owner?: Maybe<Scalars['String']>;
    _repo?: Maybe<Scalars['String']>;
    _sha?: Maybe<Scalars['String']>;
    aspects?: Maybe<Array<Maybe<PolicyComplianceAspect>>>;
    differences?: Maybe<Array<Maybe<PolicyComplianceFingerprint>>>;
    owner?: Maybe<Scalars['String']>;
    push?: Maybe<Push>;
    state?: Maybe<PolicyCompliaceState>;
    targets?: Maybe<Array<Maybe<PolicyComplianceFingerprint>>>;
    ts?: Maybe<Scalars['Int']>;
    /** The ID of this PolicyCompliance */
    id?: Maybe<Scalars['ID']>;
};

type PolicyComplianceAspect

type PolicyComplianceAspect = {
    __typename?: 'PolicyComplianceAspect';
    displayType?: Maybe<Scalars['String']>;
    manageable?: Maybe<Scalars['Boolean']>;
    type?: Maybe<Scalars['String']>;
};

type PolicyComplianceFingerprint

type PolicyComplianceFingerprint = {
    __typename?: 'PolicyComplianceFingerprint';
    data?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    displayType?: Maybe<Scalars['String']>;
    displayValue?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    sha?: Maybe<Scalars['String']>;
    type?: Maybe<Scalars['String']>;
};

type PolicyLog

type PolicyLog = {
    __typename?: 'PolicyLog';
    apply?: Maybe<ApplyPolicyLog>;
    manage?: Maybe<ManageTargetPolicyLog>;
    name?: Maybe<Scalars['String']>;
    subscribe?: Maybe<ManageSubscriptionPolicyLog>;
    ts?: Maybe<Scalars['Int']>;
    type?: Maybe<Scalars['String']>;
    /** The ID of this PolicyLog */
    id?: Maybe<Scalars['ID']>;
};

type PolicyLogSubscribeArgs

type PolicyLogSubscribeArgs = {
    owner?: Maybe<Scalars['String']>;
    repo?: Maybe<Scalars['String']>;
    branch?: Maybe<Scalars['String']>;
};

type PolicyTarget

type PolicyTarget = {
    __typename?: 'PolicyTarget';
    data?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    displayValue?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    sha?: Maybe<Scalars['String']>;
    streams?: Maybe<Array<Maybe<Scalars['ID']>>>;
    type?: Maybe<Scalars['String']>;
    /** The ID of this PolicyTarget */
    id?: Maybe<Scalars['ID']>;
};

type PolicyTargetStream

type PolicyTargetStream = {
    __typename?: 'PolicyTargetStream';
    name?: Maybe<Scalars['String']>;
    /** The ID of this PolicyTargetStream */
    id?: Maybe<Scalars['ID']>;
};

type PredicateMappingCostAnalyzer

type PredicateMappingCostAnalyzer<F> = (
    pm: PredicateMapping<F>
) => ExpectedPredicateMappingCost;

Function that can classify PredicateMappings by expected cost to evaluate

type PredicateMappingTerm

type PredicateMappingTerm<F> =
    | PredicateMapping<F>
    | Mapper<F, boolean>
    | (() => boolean | Promise<boolean>);

Predicate that can be used in predicate DSL. Can be a PredicateMapping, a function or computed boolean

type PredicateMappingVisitor

type PredicateMappingVisitor<F> = (pm: PredicateMapping<F>) => boolean;

Function that can visit a PredicateMappings. whether to visit the mapping's subcomponents, if any

type PreferenceStoreFactory

type PreferenceStoreFactory = (ctx: HandlerContext) => PreferenceStore;

Creates a PreferenceStore instance provided the HandlerContext of the current execution

type PrepareForGoalExecution

type PrepareForGoalExecution = (
    p: GitProject,
    r: GoalInvocation
) => Promise<void | ExecuteGoalResult>;

type ProgressLogFactory

type ProgressLogFactory = (
    context: HandlerContext,
    sdmGoal: SdmGoalEvent
) => Promise<ProgressLog>;

Function to create a ProgressLog for a given goal execution

type ProjectAction

type ProjectAction<PARAMS> = (
    p: Project,
    pi: PARAMS & ParametersInvocation<PARAMS>
) => Promise<void>;

Action that executes after the project has been generated and pushed to the remote repository.

type ProjectAwareGoalInvocation

type ProjectAwareGoalInvocation = GoalInvocation &
    ProjectListenerInvocation &
    ChildProcessOnProject;

Type providing access to the GoalInvocation, Project and running child process in the context of the project.

type ProjectListener

type ProjectListener = SdmListener<ProjectListenerInvocation>;

type ProjectPredicate

type ProjectPredicate = (p: Project) => Promise<boolean>;

Test against a project

type PullRequest

type PullRequest = {
    __typename?: 'PullRequest';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** the URL of the PullRequest */
    url?: Maybe<Scalars['String']>;
    /** id of  PullRequest */
    id?: Maybe<Scalars['ID']>;
    /** number of  PullRequest */
    number?: Maybe<Scalars['Float']>;
    /** prId of  PullRequest */
    prId?: Maybe<Scalars['String']>;
    /** name of  PullRequest */
    name?: Maybe<Scalars['String']>;
    /** body of  PullRequest */
    body?: Maybe<Scalars['String']>;
    /** state of  PullRequest */
    state?: Maybe<Scalars['String']>;
    /** merged of  PullRequest */
    merged?: Maybe<Scalars['Boolean']>;
    /** timestamp of  PullRequest */
    timestamp?: Maybe<Scalars['String']>;
    /** baseBranchName of  PullRequest */
    baseBranchName?: Maybe<Scalars['String']>;
    /** branchName of  PullRequest */
    branchName?: Maybe<Scalars['String']>;
    /** title of  PullRequest */
    title?: Maybe<Scalars['String']>;
    /** createdAt of  PullRequest */
    createdAt?: Maybe<Scalars['String']>;
    /** updatedAt of  PullRequest */
    updatedAt?: Maybe<Scalars['String']>;
    /** closedAt of  PullRequest */
    closedAt?: Maybe<Scalars['String']>;
    /** mergedAt of  PullRequest */
    mergedAt?: Maybe<Scalars['String']>;
    /** mergeStatus of  PullRequest */
    mergeStatus?: Maybe<MergeStatus>;
    /** action of  PullRequest */
    action?: Maybe<PullRequestAction>;
    /** PullRequest repo Repo */
    repo?: Maybe<Repo>;
    /** PullRequest head Commit */
    head?: Maybe<Commit>;
    /** PullRequest base Commit */
    base?: Maybe<Commit>;
    /** PullRequest mergeCommit Commit */
    mergeCommit?: Maybe<Commit>;
    /** PullRequest author SCMId */
    author?: Maybe<ScmId>;
    /** PullRequest merger SCMId */
    merger?: Maybe<ScmId>;
    /** PullRequest assignees SCMId */
    assignees?: Maybe<Array<Maybe<ScmId>>>;
    /** PullRequest commits Commit */
    commits?: Maybe<Array<Maybe<Commit>>>;
    /** PullRequest branch Branch */
    branch?: Maybe<Branch>;
    /** PullRequest sourceBranch Branch */
    sourceBranch?: Maybe<Branch>;
    /** PullRequest destinationBranch Branch */
    destinationBranch?: Maybe<Branch>;
    /** PullRequest labels Label */
    labels?: Maybe<Array<Maybe<Label>>>;
    /** PullRequest reviews Review */
    reviews?: Maybe<Array<Maybe<Review>>>;
    /** PullRequest reviewers SCMId */
    reviewers?: Maybe<Array<Maybe<ScmId>>>;
    /** PullRequest lastAssignedBy SCMId */
    lastAssignedBy?: Maybe<ScmId>;
    /** PullRequest comments Comment */
    comments?: Maybe<Array<Maybe<Comment>>>;
    /** PullRequest builds Build */
    builds?: Maybe<Array<Maybe<Build>>>;
};

PullRequest-Node

type PullRequestAssigneesArgs

type PullRequestAssigneesArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_ScmIdOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    avatar?: Maybe<Scalars['String']>;
};

PullRequest-Node

type PullRequestAuthorArgs

type PullRequestAuthorArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    avatar?: Maybe<Scalars['String']>;
};

PullRequest-Node

type PullRequestBaseArgs

type PullRequestBaseArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

PullRequest-Node

type PullRequestBranchArgs

type PullRequestBranchArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    isRemote?: Maybe<Scalars['Boolean']>;
    remoteRepoHtmlUrl?: Maybe<Scalars['String']>;
};

PullRequest-Node

type PullRequestBuildsArgs

type PullRequestBuildsArgs = {
    id?: Maybe<Scalars['ID']>;
    buildId?: Maybe<Scalars['String']>;
    number?: Maybe<Scalars['Int']>;
    name?: Maybe<Scalars['String']>;
    status?: Maybe<BuildStatus>;
    buildUrl?: Maybe<Scalars['String']>;
    compareUrl?: Maybe<Scalars['String']>;
    trigger?: Maybe<BuildTrigger>;
    provider?: Maybe<Scalars['String']>;
    pullRequestNumber?: Maybe<Scalars['Float']>;
    startedAt?: Maybe<Scalars['String']>;
    finishedAt?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    workflowId?: Maybe<Scalars['String']>;
    jobName?: Maybe<Scalars['String']>;
    jobId?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_BuildOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    data?: Maybe<Scalars['String']>;
};

PullRequest-Node

type PullRequestCommentsArgs

type PullRequestCommentsArgs = {
    id?: Maybe<Scalars['ID']>;
    body?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    commentId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    path?: Maybe<Scalars['String']>;
    position?: Maybe<Scalars['String']>;
    htmlUrl?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_CommentOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    commentType?: Maybe<CommentCommentType>;
};

PullRequest-Node

type PullRequestCommitsArgs

type PullRequestCommitsArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_CommitOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    timestamp?: Maybe<Scalars['String']>;
};

PullRequest-Node

type PullRequestDestinationBranchArgs

type PullRequestDestinationBranchArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    isRemote?: Maybe<Scalars['Boolean']>;
    remoteRepoHtmlUrl?: Maybe<Scalars['String']>;
};

PullRequest-Node

type PullRequestForShaQuery

type PullRequestForShaQuery = {
    __typename?: 'Query';
} & {
    PullRequest?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'PullRequest';
                } & Pick<
                    PullRequest,
                    'name' | 'title' | 'body' | 'id' | 'number'
                > & {
                        author?: Maybe<
                            {
                                __typename?: 'SCMId';
                            } & {
                                person?: Maybe<
                                    {
                                        __typename?: 'Person';
                                    } & {
                                        chatId?: Maybe<
                                            {
                                                __typename?: 'ChatId';
                                            } & Pick<ChatId, 'screenName'>
                                        >;
                                    }
                                >;
                            }
                        >;
                        repo?: Maybe<
                            {
                                __typename?: 'Repo';
                            } & CoreRepoFieldsAndChannelsFragment
                        >;
                        head?: Maybe<
                            {
                                __typename?: 'Commit';
                            } & Pick<Commit, 'message'>
                        >;
                        base?: Maybe<
                            {
                                __typename?: 'Commit';
                            } & Pick<Commit, 'sha' | 'message'>
                        >;
                    }
            >
        >
    >;
};

type PullRequestForShaQueryVariables

type PullRequestForShaQueryVariables = {
    owner: Scalars['String'];
    repo: Scalars['String'];
    sha: Scalars['String'];
};

type PullRequestHeadArgs

type PullRequestHeadArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

PullRequest-Node

type PullRequestImpact

type PullRequestImpact = {
    __typename?: 'PullRequestImpact';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** id of  PullRequestImpact */
    id?: Maybe<Scalars['ID']>;
    /** url of  PullRequestImpact */
    url?: Maybe<Scalars['String']>;
    /** data of  PullRequestImpact */
    data?: Maybe<Scalars['String']>;
    /** PullRequestImpact pullRequest PullRequest */
    pullRequest?: Maybe<PullRequest>;
};

PullRequestImpact-Node

type PullRequestImpactPullRequestArgs

type PullRequestImpactPullRequestArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    prId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    merged?: Maybe<Scalars['Boolean']>;
    timestamp?: Maybe<Scalars['String']>;
    baseBranchName?: Maybe<Scalars['String']>;
    branchName?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    closedAt?: Maybe<Scalars['String']>;
    mergedAt?: Maybe<Scalars['String']>;
    mergeStatus?: Maybe<MergeStatus>;
};

PullRequestImpact-Node

type PullRequestLabelsArgs

type PullRequestLabelsArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    default?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_LabelOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    color?: Maybe<Scalars['String']>;
};

PullRequest-Node

type PullRequestLastAssignedByArgs

type PullRequestLastAssignedByArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    avatar?: Maybe<Scalars['String']>;
};

PullRequest-Node

type PullRequestListener

type PullRequestListener = SdmListener<PullRequestListenerInvocation>;

type PullRequestMergeCommitArgs

type PullRequestMergeCommitArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

PullRequest-Node

type PullRequestMergerArgs

type PullRequestMergerArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    avatar?: Maybe<Scalars['String']>;
};

PullRequest-Node

type PullRequestRepoArgs

type PullRequestRepoArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    allowRebaseMerge?: Maybe<Scalars['Boolean']>;
    allowSquashMerge?: Maybe<Scalars['Boolean']>;
    allowMergeCommit?: Maybe<Scalars['Boolean']>;
    repoId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    defaultBranch?: Maybe<Scalars['String']>;
};

PullRequest-Node

type PullRequestReviewersArgs

type PullRequestReviewersArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_ScmIdOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    avatar?: Maybe<Scalars['String']>;
};

PullRequest-Node

type PullRequestReviewsArgs

type PullRequestReviewsArgs = {
    id?: Maybe<Scalars['ID']>;
    gitHubId?: Maybe<Scalars['String']>;
    reviewId?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<ReviewState>;
    submittedAt?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_ReviewOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    htmlUrl?: Maybe<Scalars['String']>;
    filter?: Maybe<_ReviewFilter>;
};

PullRequest-Node

type PullRequestsForBranchQuery

type PullRequestsForBranchQuery = {
    __typename?: 'Query';
} & {
    Repo?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Repo';
                } & {
                    branches?: Maybe<
                        Array<
                            Maybe<
                                {
                                    __typename?: 'Branch';
                                } & Pick<Branch, 'name'> & {
                                        pullRequests?: Maybe<
                                            Array<
                                                Maybe<
                                                    {
                                                        __typename?: 'PullRequest';
                                                    } & Pick<PullRequest, 'state'>
                                                >
                                            >
                                        >;
                                    }
                            >
                        >
                    >;
                }
            >
        >
    >;
};

type PullRequestsForBranchQueryVariables

type PullRequestsForBranchQueryVariables = {
    owner: Scalars['String'];
    repo: Scalars['String'];
    branch: Scalars['String'];
};

type PullRequestSourceBranchArgs

type PullRequestSourceBranchArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    isRemote?: Maybe<Scalars['Boolean']>;
    remoteRepoHtmlUrl?: Maybe<Scalars['String']>;
};

PullRequest-Node

type Push

type Push = {
    __typename?: 'Push';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** id of  Push */
    id?: Maybe<Scalars['ID']>;
    /** timestamp of  Push */
    timestamp?: Maybe<Scalars['String']>;
    /** branch of  Push */
    branch?: Maybe<Scalars['String']>;
    toBranch?: Maybe<Branch>;
    /** Push after Commit */
    after?: Maybe<Commit>;
    /** Push before Commit */
    before?: Maybe<Commit>;
    /** Push commits Commit */
    commits?: Maybe<Array<Maybe<Commit>>>;
    /** Push repo Repo */
    repo?: Maybe<Repo>;
    /** Push builds Build */
    builds?: Maybe<Array<Maybe<Build>>>;
    /** Pipelines associated with this Push */
    pipelines?: Maybe<Array<Maybe<Pipeline>>>;
    goals?: Maybe<Array<Maybe<SdmGoal>>>;
    goalSets?: Maybe<Array<Maybe<SdmGoalSet>>>;
    goalsDisplayState?: Maybe<Array<Maybe<SdmGoalDisplay>>>;
    compliance?: Maybe<Array<Maybe<PolicyCompliance>>>;
};

Push-Node

type PushAfterArgs

type PushAfterArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

Push-Node

type PushBeforeArgs

type PushBeforeArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

Push-Node

type PushBuildsArgs

type PushBuildsArgs = {
    id?: Maybe<Scalars['ID']>;
    buildId?: Maybe<Scalars['String']>;
    number?: Maybe<Scalars['Int']>;
    name?: Maybe<Scalars['String']>;
    status?: Maybe<BuildStatus>;
    buildUrl?: Maybe<Scalars['String']>;
    compareUrl?: Maybe<Scalars['String']>;
    trigger?: Maybe<BuildTrigger>;
    provider?: Maybe<Scalars['String']>;
    pullRequestNumber?: Maybe<Scalars['Float']>;
    startedAt?: Maybe<Scalars['String']>;
    finishedAt?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    workflowId?: Maybe<Scalars['String']>;
    jobName?: Maybe<Scalars['String']>;
    jobId?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_BuildOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    data?: Maybe<Scalars['String']>;
};

Push-Node

type PushCommitsArgs

type PushCommitsArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_CommitOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    timestamp?: Maybe<Scalars['String']>;
};

Push-Node

type PushComplianceArgs

type PushComplianceArgs = {
    _branch?: Maybe<Array<Maybe<Scalars['String']>>>;
    _owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    _repo?: Maybe<Array<Maybe<Scalars['String']>>>;
    _sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<PolicyCompliaceState>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
};

Push-Node

type PushFieldsFragment

type PushFieldsFragment = {
    __typename?: 'Push';
} & Pick<Push, 'id' | 'timestamp' | 'branch'> & {
        before?: Maybe<
            {
                __typename?: 'Commit';
            } & Pick<Commit, 'url' | 'sha' | 'message'> & {
                    committer?: Maybe<
                        {
                            __typename?: 'SCMId';
                        } & Pick<ScmId, 'login'> & {
                                person?: Maybe<
                                    {
                                        __typename?: 'Person';
                                    } & PersonFieldsFragment
                                >;
                            }
                    >;
                }
        >;
        after?: Maybe<
            {
                __typename?: 'Commit';
            } & Pick<Commit, 'url' | 'sha' | 'message'> & {
                    author?: Maybe<
                        {
                            __typename?: 'SCMId';
                        } & Pick<ScmId, 'login' | 'name'> & {
                                emails?: Maybe<
                                    Array<
                                        Maybe<
                                            {
                                                __typename?: 'Email';
                                            } & Pick<Email, 'address'>
                                        >
                                    >
                                >;
                                person?: Maybe<
                                    {
                                        __typename?: 'Person';
                                    } & PersonFieldsFragment
                                >;
                            }
                    >;
                    committer?: Maybe<
                        {
                            __typename?: 'SCMId';
                        } & Pick<ScmId, 'login' | 'name'> & {
                                emails?: Maybe<
                                    Array<
                                        Maybe<
                                            {
                                                __typename?: 'Email';
                                            } & Pick<Email, 'address'>
                                        >
                                    >
                                >;
                                person?: Maybe<
                                    {
                                        __typename?: 'Person';
                                    } & PersonFieldsFragment
                                >;
                            }
                    >;
                    image?: Maybe<
                        {
                            __typename?: 'DockerImage';
                        } & Pick<DockerImage, 'image' | 'imageName'>
                    >;
                    images?: Maybe<
                        Array<
                            Maybe<
                                {
                                    __typename?: 'DockerImage';
                                } & Pick<DockerImage, 'image' | 'imageName'>
                            >
                        >
                    >;
                    tags?: Maybe<
                        Array<
                            Maybe<
                                {
                                    __typename?: 'Tag';
                                } & Pick<
                                    Tag,
                                    'name' | 'description' | 'timestamp'
                                > & {
                                        release?: Maybe<
                                            {
                                                __typename?: 'Release';
                                            } & Pick<Release, 'name' | 'timestamp'>
                                        >;
                                    }
                            >
                        >
                    >;
                }
        >;
        repo?: Maybe<
            {
                __typename?: 'Repo';
            } & CoreRepoFieldsAndChannelsFragment
        >;
        commits?: Maybe<
            Array<
                Maybe<
                    {
                        __typename?: 'Commit';
                    } & Pick<Commit, 'url' | 'sha' | 'timestamp' | 'message'> & {
                            author?: Maybe<
                                {
                                    __typename?: 'SCMId';
                                } & Pick<ScmId, 'login' | 'name'> & {
                                        person?: Maybe<
                                            {
                                                __typename?: 'Person';
                                            } & PersonFieldsFragment
                                        >;
                                    }
                            >;
                        }
                >
            >
        >;
    };

type PushForCommitQuery

type PushForCommitQuery = {
    __typename?: 'Query';
} & {
    Commit?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Commit';
                } & {
                    pushes?: Maybe<
                        Array<
                            Maybe<
                                {
                                    __typename?: 'Push';
                                } & PushFieldsFragment
                            >
                        >
                    >;
                    repo?: Maybe<
                        {
                            __typename?: 'Repo';
                        } & {
                            org?: Maybe<
                                {
                                    __typename?: 'Org';
                                } & {
                                    provider?: Maybe<
                                        {
                                            __typename?: 'GitHubProvider';
                                        } & Pick<GitHubProvider, 'providerId'>
                                    >;
                                }
                            >;
                        }
                    >;
                }
            >
        >
    >;
};

type PushForCommitQueryVariables

type PushForCommitQueryVariables = {
    sha: Scalars['String'];
    repo: Scalars['String'];
    owner: Scalars['String'];
    providerId: Scalars['String'];
    branch: Scalars['String'];
};

type PushForSdmGoalQuery

type PushForSdmGoalQuery = {
    __typename?: 'Query';
} & {
    Commit?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Commit';
                } & {
                    pushes?: Maybe<
                        Array<
                            Maybe<
                                {
                                    __typename?: 'Push';
                                } & Pick<Push, 'id' | 'timestamp' | 'branch'> & {
                                        before?: Maybe<
                                            {
                                                __typename?: 'Commit';
                                            } & Pick<Commit, 'sha' | 'message'> & {
                                                    committer?: Maybe<
                                                        {
                                                            __typename?: 'SCMId';
                                                        } & Pick<ScmId, 'login'> & {
                                                                person?: Maybe<
                                                                    {
                                                                        __typename?: 'Person';
                                                                    } & PersonFieldsFragment
                                                                >;
                                                            }
                                                    >;
                                                }
                                        >;
                                        after?: Maybe<
                                            {
                                                __typename?: 'Commit';
                                            } & Pick<Commit, 'sha' | 'message'> & {
                                                    committer?: Maybe<
                                                        {
                                                            __typename?: 'SCMId';
                                                        } & Pick<ScmId, 'login'> & {
                                                                person?: Maybe<
                                                                    {
                                                                        __typename?: 'Person';
                                                                    } & PersonFieldsFragment
                                                                >;
                                                            }
                                                    >;
                                                }
                                        >;
                                        commits?: Maybe<
                                            Array<
                                                Maybe<
                                                    {
                                                        __typename?: 'Commit';
                                                    } & Pick<
                                                        Commit,
                                                        | 'sha'
                                                        | 'timestamp'
                                                        | 'message'
                                                    > & {
                                                            author?: Maybe<
                                                                {
                                                                    __typename?: 'SCMId';
                                                                } & Pick<
                                                                    ScmId,
                                                                    'login' | 'name'
                                                                >
                                                            >;
                                                        }
                                                >
                                            >
                                        >;
                                        repo?: Maybe<
                                            {
                                                __typename?: 'Repo';
                                            } & Pick<
                                                Repo,
                                                'owner' | 'name' | 'defaultBranch'
                                            > & {
                                                    org?: Maybe<
                                                        {
                                                            __typename?: 'Org';
                                                        } & Pick<
                                                            Org,
                                                            'owner' | 'ownerType'
                                                        > & {
                                                                provider?: Maybe<
                                                                    {
                                                                        __typename?: 'GitHubProvider';
                                                                    } & Pick<
                                                                        GitHubProvider,
                                                                        | 'providerId'
                                                                        | 'providerType'
                                                                        | 'apiUrl'
                                                                        | 'url'
                                                                    >
                                                                >;
                                                            }
                                                    >;
                                                    channels?: Maybe<
                                                        Array<
                                                            Maybe<
                                                                {
                                                                    __typename?: 'ChatChannel';
                                                                } & Pick<
                                                                    ChatChannel,
                                                                    'name' | 'id'
                                                                > & {
                                                                        team?: Maybe<
                                                                            {
                                                                                __typename?: 'ChatTeam';
                                                                            } & Pick<
                                                                                ChatTeam,
                                                                                'id'
                                                                            >
                                                                        >;
                                                                    }
                                                            >
                                                        >
                                                    >;
                                                }
                                        >;
                                    }
                            >
                        >
                    >;
                }
            >
        >
    >;
};

type PushForSdmGoalQueryVariables

type PushForSdmGoalQueryVariables = {
    owner: Scalars['String'];
    repo: Scalars['String'];
    providerId: Scalars['String'];
    branch: Scalars['String'];
    sha: Scalars['String'];
};

type PushGoalsArgs

type PushGoalsArgs = {
    approvalRequired?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
    branch?: Maybe<Array<Maybe<Scalars['String']>>>;
    data?: Maybe<Array<Maybe<Scalars['String']>>>;
    description?: Maybe<Array<Maybe<Scalars['String']>>>;
    environment?: Maybe<Array<Maybe<Scalars['String']>>>;
    error?: Maybe<Array<Maybe<Scalars['String']>>>;
    externalKey?: Maybe<Array<Maybe<Scalars['String']>>>;
    externalUrl?: Maybe<Array<Maybe<Scalars['String']>>>;
    goalSet?: Maybe<Array<Maybe<Scalars['String']>>>;
    goalSetId?: Maybe<Array<Maybe<Scalars['String']>>>;
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    parameters?: Maybe<Array<Maybe<Scalars['String']>>>;
    phase?: Maybe<Array<Maybe<Scalars['String']>>>;
    preApprovalRequired?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
    registration?: Maybe<Array<Maybe<Scalars['String']>>>;
    retryFeasible?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
    sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    signature?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<SdmGoalState>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
    uniqueName?: Maybe<Array<Maybe<Scalars['String']>>>;
    url?: Maybe<Array<Maybe<Scalars['String']>>>;
    version?: Maybe<Array<Maybe<Scalars['Int']>>>;
};

Push-Node

type PushGoalsDisplayStateArgs

type PushGoalsDisplayStateArgs = {
    branch?: Maybe<Array<Maybe<Scalars['String']>>>;
    format?: Maybe<Array<Maybe<SdmGoalDisplayFormat>>>;
    sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<SdmGoalDisplayState>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
};

Push-Node

type PushGoalSetsArgs

type PushGoalSetsArgs = {
    branch?: Maybe<Array<Maybe<Scalars['String']>>>;
    goalSet?: Maybe<Array<Maybe<Scalars['String']>>>;
    goalSetId?: Maybe<Array<Maybe<Scalars['String']>>>;
    sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<SdmGoalState>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
};

Push-Node

type PushImpactListener

type PushImpactListener<R = DefaultPushImpactListenerResult> = (
    i: PushImpactListenerInvocation
) => Promise<R>;

Reaction on a push, with the code available. Can optionally return a response that determines whether to ask for approval or terminate current delivery flow.

type PushImpactListenerRegisterable

type PushImpactListenerRegisterable<R = DefaultPushImpactListenerResult> =
    | PushImpactListenerRegistration<R>
    | PushImpactListener<R>;

Something we can register as a push reaction

type PushImpactListenerRegistration

type PushImpactListenerRegistration<R = DefaultPushImpactListenerResult> =
    PushRegistration<PushImpactListener<R>>;

Used to register actions on a push that can potentially influence downstream goals. Will be invoked if a PushReactionGoal has been set for the given push. Use ReviewerRegistration if you want to return a structured review.

type PushLink

type PushLink = {
    afterSha: Scalars['String'];
    branchName: Scalars['String'];
};

type PushListener

type PushListener = SdmListener<PushListenerInvocation>;

type PushPipelinesArgs

type PushPipelinesArgs = {
    pipelineId?: Maybe<Scalars['ID']>;
};

Push-Node

type PushRepoArgs

type PushRepoArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    allowRebaseMerge?: Maybe<Scalars['Boolean']>;
    allowSquashMerge?: Maybe<Scalars['Boolean']>;
    allowMergeCommit?: Maybe<Scalars['Boolean']>;
    repoId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    defaultBranch?: Maybe<Scalars['String']>;
};

Push-Node

type PushTestOrProjectPredicate

type PushTestOrProjectPredicate = PushTest | ProjectPredicate;

type Query

type Query = {
    __typename?: 'Query';
    AtomistSkill: Array<ConfiguredAtomistSkill>;
    activeSkill?: Maybe<ConfiguredAtomistSkill>;
    getSkill?: Maybe<ConfiguredAtomistSkill>;
    skillExecution?: Maybe<AtomistSkillExecution>;
    skillExecutions: Array<AtomistSkillExecution>;
    skills: AtomistSkills;
    TeamConfiguration?: Maybe<Array<Maybe<TeamConfiguration>>>;
    listDisabledRegistrations?: Maybe<Array<Maybe<AtomistRegistration>>>;
    Issue?: Maybe<Array<Maybe<Issue>>>;
    Comment?: Maybe<Array<Maybe<Comment>>>;
    Label?: Maybe<Array<Maybe<Label>>>;
    Repo?: Maybe<Array<Maybe<Repo>>>;
    Commit?: Maybe<Array<Maybe<Commit>>>;
    Push?: Maybe<Array<Maybe<Push>>>;
    Build?: Maybe<Array<Maybe<Build>>>;
    Pipeline?: Maybe<Array<Maybe<Pipeline>>>;
    Stage?: Maybe<Array<Maybe<Stage>>>;
    Job?: Maybe<Array<Maybe<Job>>>;
    Workflow?: Maybe<Array<Maybe<Workflow>>>;
    Branch?: Maybe<Array<Maybe<Branch>>>;
    DeletedBranch?: Maybe<Array<Maybe<DeletedBranch>>>;
    ChatId?: Maybe<Array<Maybe<ChatId>>>;
    ChatChannel?: Maybe<Array<Maybe<ChatChannel>>>;
    PullRequest?: Maybe<Array<Maybe<PullRequest>>>;
    Org?: Maybe<Array<Maybe<Org>>>;
    GitHubAppInstallation?: Maybe<Array<Maybe<GitHubAppInstallation>>>;
    SCMId?: Maybe<Array<Maybe<ScmId>>>;
    GitHubAppResourceUser?: Maybe<Array<Maybe<GitHubAppResourceUser>>>;
    GitHubId?: Maybe<Array<Maybe<GitHubId>>>;
    Tag?: Maybe<Array<Maybe<Tag>>>;
    K8Pod?: Maybe<Array<Maybe<K8Pod>>>;
    K8Container?: Maybe<Array<Maybe<K8Container>>>;
    DockerImage?: Maybe<Array<Maybe<DockerImage>>>;
    ImageLinked?: Maybe<Array<Maybe<ImageLinked>>>;
    Release?: Maybe<Array<Maybe<Release>>>;
    HerokuApp?: Maybe<Array<Maybe<HerokuApp>>>;
    Application?: Maybe<Array<Maybe<Application>>>;
    Team?: Maybe<Array<Maybe<Team>>>;
    ChatTeam?: Maybe<Array<Maybe<ChatTeam>>>;
    Person?: Maybe<Array<Maybe<Person>>>;
    Status?: Maybe<Array<Maybe<Status>>>;
    CheckSuite?: Maybe<Array<Maybe<CheckSuite>>>;
    CheckRun?: Maybe<Array<Maybe<CheckRun>>>;
    Email?: Maybe<Array<Maybe<Email>>>;
    PushImpact?: Maybe<Array<Maybe<DeprecatedPushImpact>>>;
    PullRequestImpact?: Maybe<Array<Maybe<PullRequestImpact>>>;
    GitHubProvider?: Maybe<Array<Maybe<GitHubProvider>>>;
    SCMProvider?: Maybe<Array<Maybe<ScmProvider>>>;
    GitHubAppResourceProvider?: Maybe<Array<Maybe<GitHubAppResourceProvider>>>;
    UserJoinedChannel?: Maybe<Array<Maybe<UserJoinedChannel>>>;
    Webhook?: Maybe<Array<Maybe<Webhook>>>;
    ChannelLink?: Maybe<Array<Maybe<ChannelLink>>>;
    Review?: Maybe<Array<Maybe<Review>>>;
    DockerRegistryProvider?: Maybe<Array<Maybe<DockerRegistryProvider>>>;
    DockerHubRegistryProvider: Array<DockerHubRegistryProvider>;
    GoogleContainerRegistryProvider: Array<GoogleContainerRegistryProvider>;
    JFrogDockerRegistryProvider: Array<JFrogDockerRegistryProvider>;
    DockerRegistry: Array<DockerRegistry>;
    DockerRegistryImage: Array<DockerRegistryImage>;
    GoogleCloudPlatformProvider: Array<GoogleCloudPlatformProvider>;
    KubernetesClusterProvider: Array<KubernetesClusterProvider>;
    ArtifactoryMavenRepositoryProvider: Array<ArtifactoryMavenRepositoryProvider>;
    MavenRepositoryProvider: Array<MavenRepositoryProvider>;
    NpmJSRegistryProvider: Array<NpmJsRegistryProvider>;
    NpmRegistryProvider: Array<NpmRegistryProvider>;
    GitHubNpmRegistryProvider: Array<GitHubNpmRegistryProvider>;
    ResourceProvider?: Maybe<Array<Maybe<ResourceProvider>>>;
    Resource: Array<Resource>;
    GenericResourceUser?: Maybe<Array<Maybe<GenericResourceUser>>>;
    ResourceUser?: Maybe<Array<Maybe<ResourceUser>>>;
    SystemAccount?: Maybe<Array<Maybe<SystemAccount>>>;
    Credential?: Maybe<Array<Maybe<Credential>>>;
    OAuthToken?: Maybe<Array<Maybe<OAuthToken>>>;
    Password?: Maybe<Array<Maybe<Password>>>;
    GenericResourceProvider?: Maybe<Array<Maybe<GenericResourceProvider>>>;
    BinaryRepositoryProvider?: Maybe<Array<Maybe<BinaryRepositoryProvider>>>;
    SecretProvider: Array<SecretProvider>;
    CommitFingerprintImpact: Array<Maybe<CommitFingerprintImpact>>;
    /** Find a single SourceFingerprint by its sha, type and name */
    SourceFingerprint?: Maybe<SourceFingerprint>;
    /** Search for fingerprints, with paging */
    commitsWithFingerprints: CommitsWithFingerprints;
    /** Search find all distinct fingerprints on head commits for type and name */
    distinctHeadCommitFingerprints: Array<SourceFingerprint>;
    fingerprintAggregates?: Maybe<FingerprintAggregates>;
    fingerprintTargets: Array<FingerprintTarget>;
    /** Find the count of all repos that have been analyzed */
    headCommitFingerprintCounts: FingerprintCounts;
    /** Find all repos that contain named fingerprint in the HEAD commit */
    headCommitsWithFingerprint: Array<FingerprintedCommit>;
    /** Return AtmJobs */
    AtmJob?: Maybe<Array<AtmJob>>;
    /** Return AtmJobTasks */
    AtmJobTask?: Maybe<Array<AtmJobTask>>;
    AtomistLog: Array<AtomistLog>;
    ok: Ok;
    /**
     * Generate a report breaking down the number of events submitted by a given team.
     * This query is in beta and may change substantially before being finalized.
     **/
    eventsReport: Array<EventsReportRow>;
    /**
     * Generate a report breaking down the number of events which have been throttled for a given team.
     * This query is in beta and may change substantially before being finalized.
     **/
    throttledEventsReport: Array<EventsReportRow>;
    /** Auto-generated query for Card */
    Card?: Maybe<Array<Maybe<Card>>>;
    /** Auto-generated query for Notification */
    Notification?: Maybe<Array<Maybe<Notification>>>;
    /** Auto-generated query for CommitIssueRelationship */
    CommitIssueRelationship?: Maybe<Array<Maybe<CommitIssueRelationship>>>;
    /** Auto-generated query for Deployment */
    Deployment?: Maybe<Array<Maybe<Deployment>>>;
    /** Auto-generated query for IssueRelationship */
    IssueRelationship?: Maybe<Array<Maybe<IssueRelationship>>>;
    /** Auto-generated query for SdmGoal */
    SdmGoal?: Maybe<Array<Maybe<SdmGoal>>>;
    /** Auto-generated query for SdmGoalSet */
    SdmGoalSet?: Maybe<Array<Maybe<SdmGoalSet>>>;
    /** Auto-generated query for SdmGoalDisplay */
    SdmGoalDisplay?: Maybe<Array<Maybe<SdmGoalDisplay>>>;
    /** Auto-generated query for SdmBuildIdentifier */
    SdmBuildIdentifier?: Maybe<Array<Maybe<SdmBuildIdentifier>>>;
    /** Auto-generated query for SdmDeployEnablement */
    SdmDeployEnablement?: Maybe<Array<Maybe<SdmDeployEnablement>>>;
    /** Auto-generated query for SdmVersion */
    SdmVersion?: Maybe<Array<Maybe<SdmVersion>>>;
    /** Auto-generated query for SdmGoalSetBadge */
    SdmGoalSetBadge?: Maybe<Array<Maybe<SdmGoalSetBadge>>>;
    /** Auto-generated query for SdmPreference */
    SdmPreference?: Maybe<Array<Maybe<SdmPreference>>>;
    /** Auto-generated query for SdmRepoProvenance */
    SdmRepoProvenance?: Maybe<Array<Maybe<SdmRepoProvenance>>>;
    /** Auto-generated query for PolicyLog */
    PolicyLog?: Maybe<Array<Maybe<PolicyLog>>>;
    /** Auto-generated query for PolicyCompliance */
    PolicyCompliance?: Maybe<Array<Maybe<PolicyCompliance>>>;
    /** Auto-generated query for PolicyTargetStream */
    PolicyTargetStream?: Maybe<Array<Maybe<PolicyTargetStream>>>;
    /** Auto-generated query for PolicyTarget */
    PolicyTarget?: Maybe<Array<Maybe<PolicyTarget>>>;
    /** Auto-generated query for LifecycleAttachment */
    LifecycleAttachment?: Maybe<Array<Maybe<LifecycleAttachment>>>;
    /** Auto-generated query for AspectRegistration */
    AspectRegistration?: Maybe<Array<Maybe<AspectRegistration>>>;
    /** Find a commit by sha */
    commitBySha?: Maybe<Commit>;
    /** Find a Push using after-sha and branch */
    pushBySha?: Maybe<Push>;
    /** Find repo by name, owner and provider id */
    linkedRepo?: Maybe<Repo>;
    /** Find SourceFingerprint by name, owner and provider id */
    linkedFingerprint?: Maybe<SourceFingerprint>;
    /** Fetch a PR by its id */
    pullRequestById?: Maybe<PullRequest>;
};

type QueryActiveSkillArgs

type QueryActiveSkillArgs = {
    name: Scalars['String'];
    namespace: Scalars['String'];
};

type QueryApplicationArgs

type QueryApplicationArgs = {
    id?: Maybe<Scalars['ID']>;
    state?: Maybe<Scalars['String']>;
    host?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    domain?: Maybe<Scalars['String']>;
    data?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    states?: Maybe<Array<Maybe<Scalars['String']>>>;
    hosts?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    domains?: Maybe<Array<Maybe<Scalars['String']>>>;
    datas?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_ApplicationOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryArtifactoryMavenRepositoryProviderArgs

type QueryArtifactoryMavenRepositoryProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryAspectRegistrationArgs

type QueryAspectRegistrationArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    category?: Maybe<Array<Maybe<Scalars['String']>>>;
    description?: Maybe<Array<Maybe<Scalars['String']>>>;
    displayName?: Maybe<Array<Maybe<Scalars['String']>>>;
    endpoint?: Maybe<Array<Maybe<Scalars['String']>>>;
    manageable?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    shortName?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<AspectRegistrationState>>>;
    unit?: Maybe<Array<Maybe<Scalars['String']>>>;
    url?: Maybe<Array<Maybe<Scalars['String']>>>;
    uuid?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type QueryAtmJobArgs

type QueryAtmJobArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    state?: Maybe<AtmJobState>;
};

type QueryAtmJobTaskArgs

type QueryAtmJobTaskArgs = {
    id?: Maybe<Scalars['ID']>;
    jobId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    state?: Maybe<AtmJobTaskState>;
};

type QueryAtomistLogArgs

type QueryAtomistLogArgs = {
    _after?: Maybe<Scalars['String']>;
    _before?: Maybe<Scalars['String']>;
    _first?: Maybe<Scalars['Int']>;
    _offset?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _ordering?: Maybe<_AtomistLogOrdering>;
    _search?: Maybe<Scalars['String']>;
    category?: Maybe<Array<Scalars['String']>>;
    id?: Maybe<Scalars['ID']>;
    level?: Maybe<Array<Scalars['String']>>;
    message?: Maybe<Array<Scalars['String']>>;
    team_id?: Maybe<Array<Scalars['String']>>;
    timestamp?: Maybe<Array<Scalars['String']>>;
};

type QueryAtomistSkillArgs

type QueryAtomistSkillArgs = {
    id: Scalars['ID'];
};

type QueryBinaryRepositoryProviderArgs

type QueryBinaryRepositoryProviderArgs = {
    id?: Maybe<Scalars['ID']>;
    url?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    type?: Maybe<BinaryRepositoryType>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryBranchArgs

type QueryBranchArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    isRemote?: Maybe<Scalars['Boolean']>;
    remoteRepoHtmlUrl?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    remoteRepoHtmlUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_BranchOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryBuildArgs

type QueryBuildArgs = {
    id?: Maybe<Scalars['ID']>;
    buildId?: Maybe<Scalars['String']>;
    number?: Maybe<Scalars['Int']>;
    name?: Maybe<Scalars['String']>;
    status?: Maybe<BuildStatus>;
    buildUrl?: Maybe<Scalars['String']>;
    compareUrl?: Maybe<Scalars['String']>;
    trigger?: Maybe<BuildTrigger>;
    provider?: Maybe<Scalars['String']>;
    pullRequestNumber?: Maybe<Scalars['Float']>;
    startedAt?: Maybe<Scalars['String']>;
    finishedAt?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    workflowId?: Maybe<Scalars['String']>;
    jobName?: Maybe<Scalars['String']>;
    jobId?: Maybe<Scalars['String']>;
    data?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    buildIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    numbers?: Maybe<Array<Maybe<Scalars['Int']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    statuss?: Maybe<Array<Maybe<BuildStatus>>>;
    buildUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    compareUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    triggers?: Maybe<Array<Maybe<BuildTrigger>>>;
    providers?: Maybe<Array<Maybe<Scalars['String']>>>;
    pullRequestNumbers?: Maybe<Array<Maybe<Scalars['Float']>>>;
    startedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    finishedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    workflowIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    jobNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    jobIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    datas?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_BuildOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryCardArgs

type QueryCardArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    key?: Maybe<Array<Maybe<Scalars['String']>>>;
    post?: Maybe<Array<Maybe<Scalars['String']>>>;
    shortTitle?: Maybe<Array<Maybe<Scalars['String']>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
    ttl?: Maybe<Array<Maybe<Scalars['Int']>>>;
    type?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type QueryChannelLinkArgs

type QueryChannelLinkArgs = {
    id?: Maybe<Scalars['ID']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    orderBy?: Maybe<Array<Maybe<_ChannelLinkOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryChatChannelArgs

type QueryChatChannelArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    normalizedName?: Maybe<Scalars['String']>;
    channelId?: Maybe<Scalars['String']>;
    isDefault?: Maybe<Scalars['Boolean']>;
    botInvitedSelf?: Maybe<Scalars['Boolean']>;
    archived?: Maybe<Scalars['Boolean']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    providers?: Maybe<Array<Maybe<Scalars['String']>>>;
    normalizedNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    channelIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_ChatChannelOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_ChatChannelFilter>;
};

type QueryChatIdArgs

type QueryChatIdArgs = {
    id?: Maybe<Scalars['ID']>;
    screenName?: Maybe<Scalars['String']>;
    userId?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    isAtomistBot?: Maybe<Scalars['String']>;
    isOwner?: Maybe<Scalars['String']>;
    isPrimaryOwner?: Maybe<Scalars['String']>;
    isAdmin?: Maybe<Scalars['String']>;
    isBot?: Maybe<Scalars['String']>;
    timezoneLabel?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    screenNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    userIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    providers?: Maybe<Array<Maybe<Scalars['String']>>>;
    timezoneLabels?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_ChatIdOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryChatTeamArgs

type QueryChatTeamArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    tenantId?: Maybe<Scalars['String']>;
    domain?: Maybe<Scalars['String']>;
    messageCount?: Maybe<Scalars['Float']>;
    emailDomain?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    providers?: Maybe<Array<Maybe<Scalars['String']>>>;
    domains?: Maybe<Array<Maybe<Scalars['String']>>>;
    messageCounts?: Maybe<Array<Maybe<Scalars['Float']>>>;
    emailDomains?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_ChatTeamOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryCheckRunArgs

type QueryCheckRunArgs = {
    id?: Maybe<Scalars['ID']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    orderBy?: Maybe<Array<Maybe<_CheckRunOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_CheckRunFilter>;
};

type QueryCheckSuiteArgs

type QueryCheckSuiteArgs = {
    id?: Maybe<Scalars['ID']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    orderBy?: Maybe<Array<Maybe<_CheckSuiteOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_CheckSuiteFilter>;
};

type QueryCommentArgs

type QueryCommentArgs = {
    id?: Maybe<Scalars['ID']>;
    body?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    commentId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    path?: Maybe<Scalars['String']>;
    position?: Maybe<Scalars['String']>;
    htmlUrl?: Maybe<Scalars['String']>;
    commentType?: Maybe<CommentCommentType>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    bodys?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    createdAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    updatedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    commentIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    gitHubIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    paths?: Maybe<Array<Maybe<Scalars['String']>>>;
    positions?: Maybe<Array<Maybe<Scalars['String']>>>;
    htmlUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    commentTypes?: Maybe<Array<Maybe<CommentCommentType>>>;
    orderBy?: Maybe<Array<Maybe<_CommentOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryCommitArgs

type QueryCommitArgs = {
    id?: Maybe<Scalars['ID']>;
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    shas?: Maybe<Array<Maybe<Scalars['String']>>>;
    messages?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_CommitOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_CommitFilter>;
};

type QueryCommitByShaArgs

type QueryCommitByShaArgs = {
    sha: Scalars['String'];
};

type QueryCommitFingerprintImpactArgs

type QueryCommitFingerprintImpactArgs = {
    id?: Maybe<Scalars['ID']>;
    type?: Maybe<Scalars['String']>;
};

type QueryCommitIssueRelationshipArgs

type QueryCommitIssueRelationshipArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    type?: Maybe<Array<Maybe<CommitIssueRelationshipType>>>;
};

type QueryCommitsWithFingerprintsArgs

type QueryCommitsWithFingerprintsArgs = {
    _paging?: Maybe<PagingInfoInput>;
    displayName?: Maybe<Scalars['String']>;
    displayValue?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    repoId?: Maybe<Scalars['String']>;
    type?: Maybe<Scalars['String']>;
};

type QueryCredentialArgs

type QueryCredentialArgs = {
    id?: Maybe<Scalars['ID']>;
    _id?: Maybe<Scalars['Int']>;
};

type QueryDeletedBranchArgs

type QueryDeletedBranchArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_DeletedBranchOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryDeploymentArgs

type QueryDeploymentArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    environment?: Maybe<Array<Maybe<Scalars['String']>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
};

type QueryDistinctHeadCommitFingerprintsArgs

type QueryDistinctHeadCommitFingerprintsArgs = {
    name: Scalars['String'];
    type: Scalars['String'];
};

type QueryDockerHubRegistryProviderArgs

type QueryDockerHubRegistryProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryDockerImageArgs

type QueryDockerImageArgs = {
    image?: Maybe<Scalars['String']>;
    imageName?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    images?: Maybe<Array<Maybe<Scalars['String']>>>;
    imageNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_DockerImageOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryDockerRegistryArgs

type QueryDockerRegistryArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryDockerRegistryImageArgs

type QueryDockerRegistryImageArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_DockerRegistryImageFilter>;
};

type QueryDockerRegistryProviderArgs

type QueryDockerRegistryProviderArgs = {
    id?: Maybe<Scalars['ID']>;
    url?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    type?: Maybe<DockerRegistryType>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryEmailArgs

type QueryEmailArgs = {
    address?: Maybe<Scalars['String']>;
    addresss?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_EmailOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryEventsReportArgs

type QueryEventsReportArgs = {
    bucketUnit?: Maybe<BucketUnit>;
    eventTypes?: Maybe<Array<EventType>>;
    from?: Maybe<Scalars['String']>;
    to?: Maybe<Scalars['String']>;
};

type QueryFingerprintAggregatesArgs

type QueryFingerprintAggregatesArgs = {
    name: Scalars['String'];
    type: Scalars['String'];
};

type QueryFingerprintTargetsArgs

type QueryFingerprintTargetsArgs = {
    name?: Maybe<Scalars['String']>;
    type?: Maybe<Scalars['String']>;
};

type QueryGenericResourceProviderArgs

type QueryGenericResourceProviderArgs = {
    id?: Maybe<Scalars['ID']>;
    url?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    type?: Maybe<Scalars['String']>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryGenericResourceUserArgs

type QueryGenericResourceUserArgs = {
    login?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['ID']>;
    _id?: Maybe<Scalars['Int']>;
};

type QueryGetSkillArgs

type QueryGetSkillArgs = {
    maturity?: Maybe<AtomistSkillMaturityLevel>;
    name: Scalars['String'];
    namespace: Scalars['String'];
    version?: Maybe<Scalars['String']>;
};

type QueryGitHubAppInstallationArgs

type QueryGitHubAppInstallationArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    ownerType?: Maybe<OwnerType>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    owners?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_GitHubAppInstallationOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryGitHubAppResourceProviderArgs

type QueryGitHubAppResourceProviderArgs = {
    id?: Maybe<Scalars['ID']>;
    providerId?: Maybe<Scalars['String']>;
    _id?: Maybe<Scalars['Int']>;
};

type QueryGitHubAppResourceUserArgs

type QueryGitHubAppResourceUserArgs = {
    id?: Maybe<Scalars['ID']>;
    login?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_GitHubAppResourceUserOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryGitHubIdArgs

type QueryGitHubIdArgs = {
    id?: Maybe<Scalars['ID']>;
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    logins?: Maybe<Array<Maybe<Scalars['String']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_GitHubIdOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryGitHubNpmRegistryProviderArgs

type QueryGitHubNpmRegistryProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryGitHubProviderArgs

type QueryGitHubProviderArgs = {
    id?: Maybe<Scalars['ID']>;
    private?: Maybe<Scalars['Boolean']>;
    url?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
    apiUrl?: Maybe<Scalars['String']>;
    gitUrl?: Maybe<Scalars['String']>;
    providerType?: Maybe<ProviderType>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    urls?: Maybe<Array<Maybe<Scalars['String']>>>;
    providerIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    apiUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    gitUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    providerTypes?: Maybe<Array<Maybe<ProviderType>>>;
    orderBy?: Maybe<Array<Maybe<_GitHubProviderOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryGoogleCloudPlatformProviderArgs

type QueryGoogleCloudPlatformProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryGoogleContainerRegistryProviderArgs

type QueryGoogleContainerRegistryProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryHeadCommitFingerprintCountsArgs

type QueryHeadCommitFingerprintCountsArgs = {
    name?: Maybe<Scalars['String']>;
    type?: Maybe<Scalars['String']>;
};

type QueryHeadCommitsWithFingerprintArgs

type QueryHeadCommitsWithFingerprintArgs = {
    displayName?: Maybe<Scalars['String']>;
    displayValue?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    repoId?: Maybe<Scalars['String']>;
    type?: Maybe<Scalars['String']>;
};

type QueryHerokuAppArgs

type QueryHerokuAppArgs = {
    app?: Maybe<Scalars['String']>;
    url?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    user?: Maybe<Scalars['String']>;
    appId?: Maybe<Scalars['String']>;
    release?: Maybe<Scalars['String']>;
    apps?: Maybe<Array<Maybe<Scalars['String']>>>;
    urls?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    users?: Maybe<Array<Maybe<Scalars['String']>>>;
    appIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    releases?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_HerokuAppOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryImageLinkedArgs

type QueryImageLinkedArgs = {
    timestamp?: Maybe<Scalars['String']>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_ImageLinkedOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryIssueArgs

type QueryIssueArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    name?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<IssueState>;
    timestamp?: Maybe<Scalars['String']>;
    action?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    closedAt?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    numbers?: Maybe<Array<Maybe<Scalars['Float']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    titles?: Maybe<Array<Maybe<Scalars['String']>>>;
    bodys?: Maybe<Array<Maybe<Scalars['String']>>>;
    states?: Maybe<Array<Maybe<IssueState>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    actions?: Maybe<Array<Maybe<Scalars['String']>>>;
    createdAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    updatedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    closedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_IssueOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_IssueFilter>;
};

type QueryIssueRelationshipArgs

type QueryIssueRelationshipArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    relationshipId?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<Scalars['String']>>>;
    type?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type QueryJFrogDockerRegistryProviderArgs

type QueryJFrogDockerRegistryProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryJobArgs

type QueryJobArgs = {
    _id?: Maybe<Scalars['Int']>;
    name?: Maybe<Scalars['String']>;
    jobId?: Maybe<Scalars['ID']>;
};

type QueryK8ContainerArgs

type QueryK8ContainerArgs = {
    name?: Maybe<Scalars['String']>;
    imageName?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    environment?: Maybe<Scalars['String']>;
    clusterName?: Maybe<Scalars['String']>;
    containerJSON?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    stateReason?: Maybe<Scalars['String']>;
    ready?: Maybe<Scalars['Boolean']>;
    restartCount?: Maybe<Scalars['Int']>;
    statusJSON?: Maybe<Scalars['String']>;
    resourceVersion?: Maybe<Scalars['Int']>;
    containerID?: Maybe<Scalars['String']>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    imageNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    environments?: Maybe<Array<Maybe<Scalars['String']>>>;
    containerJSONs?: Maybe<Array<Maybe<Scalars['String']>>>;
    states?: Maybe<Array<Maybe<Scalars['String']>>>;
    stateReasons?: Maybe<Array<Maybe<Scalars['String']>>>;
    restartCounts?: Maybe<Array<Maybe<Scalars['Int']>>>;
    statusJSONs?: Maybe<Array<Maybe<Scalars['String']>>>;
    resourceVersions?: Maybe<Array<Maybe<Scalars['Int']>>>;
    containerIDs?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_K8ContainerOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryK8PodArgs

type QueryK8PodArgs = {
    name?: Maybe<Scalars['String']>;
    phase?: Maybe<Scalars['String']>;
    environment?: Maybe<Scalars['String']>;
    clusterName?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    baseName?: Maybe<Scalars['String']>;
    namespace?: Maybe<Scalars['String']>;
    statusJSON?: Maybe<Scalars['String']>;
    host?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    specsJSON?: Maybe<Scalars['String']>;
    envJSON?: Maybe<Scalars['String']>;
    metadataJSON?: Maybe<Scalars['String']>;
    containersCrashLoopBackOff?: Maybe<Scalars['Boolean']>;
    resourceVersion?: Maybe<Scalars['Int']>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    phases?: Maybe<Array<Maybe<Scalars['String']>>>;
    environments?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    baseNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    namespaces?: Maybe<Array<Maybe<Scalars['String']>>>;
    statusJSONs?: Maybe<Array<Maybe<Scalars['String']>>>;
    hosts?: Maybe<Array<Maybe<Scalars['String']>>>;
    states?: Maybe<Array<Maybe<Scalars['String']>>>;
    specsJSONs?: Maybe<Array<Maybe<Scalars['String']>>>;
    envJSONs?: Maybe<Array<Maybe<Scalars['String']>>>;
    metadataJSONs?: Maybe<Array<Maybe<Scalars['String']>>>;
    resourceVersions?: Maybe<Array<Maybe<Scalars['Int']>>>;
    orderBy?: Maybe<Array<Maybe<_K8PodOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_K8PodFilter>;
};

type QueryKubernetesClusterProviderArgs

type QueryKubernetesClusterProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryLabelArgs

type QueryLabelArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    default?: Maybe<Scalars['String']>;
    color?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    defaults?: Maybe<Array<Maybe<Scalars['String']>>>;
    colors?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_LabelOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryLifecycleAttachmentArgs

type QueryLifecycleAttachmentArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    body?: Maybe<Array<Maybe<Scalars['String']>>>;
    configuration?: Maybe<Array<Maybe<Scalars['String']>>>;
    contentType?: Maybe<Array<Maybe<Scalars['String']>>>;
    identifier?: Maybe<Array<Maybe<Scalars['String']>>>;
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    skill?: Maybe<Array<Maybe<Scalars['String']>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
    type?: Maybe<Array<Maybe<LifecycleAttachmentType>>>;
};

type QueryLinkedFingerprintArgs

type QueryLinkedFingerprintArgs = {
    name: Scalars['String'];
    sha: Scalars['String'];
    type: Scalars['String'];
};

type QueryLinkedRepoArgs

type QueryLinkedRepoArgs = {
    name: Scalars['String'];
    owner: Scalars['String'];
    provider: Scalars['String'];
};

type QueryMavenRepositoryProviderArgs

type QueryMavenRepositoryProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryNotificationArgs

type QueryNotificationArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    contentType?: Maybe<Scalars['String']>;
    correlationId?: Maybe<Scalars['String']>;
    key?: Maybe<Scalars['String']>;
    post?: Maybe<Array<Maybe<Scalars['String']>>>;
    ts?: Maybe<Scalars['Int']>;
    ttl?: Maybe<Array<Maybe<Scalars['Int']>>>;
};

type QueryNpmJsRegistryProviderArgs

type QueryNpmJsRegistryProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryNpmRegistryProviderArgs

type QueryNpmRegistryProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryOAuthTokenArgs

type QueryOAuthTokenArgs = {
    id?: Maybe<Scalars['ID']>;
    _id?: Maybe<Scalars['Int']>;
};

type QueryOrgArgs

type QueryOrgArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    ownerType?: Maybe<OwnerType>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    owners?: Maybe<Array<Maybe<Scalars['String']>>>;
    ownerTypes?: Maybe<Array<Maybe<OwnerType>>>;
    orderBy?: Maybe<Array<Maybe<_OrgOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_OrgFilter>;
};

type QueryPasswordArgs

type QueryPasswordArgs = {
    id?: Maybe<Scalars['ID']>;
    _id?: Maybe<Scalars['Int']>;
};

type QueryPersonArgs

type QueryPersonArgs = {
    id?: Maybe<Scalars['ID']>;
    forename?: Maybe<Scalars['String']>;
    surname?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    forenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    surnames?: Maybe<Array<Maybe<Scalars['String']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_PersonOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryPipelineArgs

type QueryPipelineArgs = {
    _id?: Maybe<Scalars['Int']>;
    pipelineId?: Maybe<Scalars['ID']>;
    provider?: Maybe<Scalars['String']>;
    Status?: Maybe<PipelineStatus>;
};

type QueryPolicyComplianceArgs

type QueryPolicyComplianceArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    _branch?: Maybe<Array<Maybe<Scalars['String']>>>;
    _owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    _repo?: Maybe<Array<Maybe<Scalars['String']>>>;
    _sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<PolicyCompliaceState>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
};

type QueryPolicyLogArgs

type QueryPolicyLogArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
    type?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type QueryPolicyTargetArgs

type QueryPolicyTargetArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    data?: Maybe<Array<Maybe<Scalars['String']>>>;
    displayName?: Maybe<Array<Maybe<Scalars['String']>>>;
    displayValue?: Maybe<Array<Maybe<Scalars['String']>>>;
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    streams?: Maybe<Array<Maybe<Scalars['ID']>>>;
    type?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type QueryPolicyTargetStreamArgs

type QueryPolicyTargetStreamArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type QueryPullRequestArgs

type QueryPullRequestArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    prId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    merged?: Maybe<Scalars['Boolean']>;
    timestamp?: Maybe<Scalars['String']>;
    baseBranchName?: Maybe<Scalars['String']>;
    branchName?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    closedAt?: Maybe<Scalars['String']>;
    mergedAt?: Maybe<Scalars['String']>;
    mergeStatus?: Maybe<MergeStatus>;
    action?: Maybe<PullRequestAction>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    numbers?: Maybe<Array<Maybe<Scalars['Float']>>>;
    prIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    bodys?: Maybe<Array<Maybe<Scalars['String']>>>;
    states?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    baseBranchNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    branchNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    titles?: Maybe<Array<Maybe<Scalars['String']>>>;
    createdAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    updatedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    closedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    mergedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    mergeStatuss?: Maybe<Array<Maybe<MergeStatus>>>;
    actions?: Maybe<Array<Maybe<PullRequestAction>>>;
    orderBy?: Maybe<Array<Maybe<_PullRequestOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_PullRequestFilter>;
};

type QueryPullRequestByIdArgs

type QueryPullRequestByIdArgs = {
    id: Scalars['ID'];
};

type QueryPullRequestImpactArgs

type QueryPullRequestImpactArgs = {
    id?: Maybe<Scalars['ID']>;
    url?: Maybe<Scalars['String']>;
    data?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    urls?: Maybe<Array<Maybe<Scalars['String']>>>;
    datas?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_PullRequestImpactOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryPushArgs

type QueryPushArgs = {
    id?: Maybe<Scalars['ID']>;
    timestamp?: Maybe<Scalars['String']>;
    branch?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    branchs?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_PushOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_PushFilter>;
};

type QueryPushByShaArgs

type QueryPushByShaArgs = {
    branchName: Scalars['String'];
    afterSha: Scalars['String'];
    ownerName?: Maybe<Scalars['String']>;
    repoName?: Maybe<Scalars['String']>;
};

type QueryPushImpactArgs

type QueryPushImpactArgs = {
    id?: Maybe<Scalars['ID']>;
    url?: Maybe<Scalars['String']>;
    data?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    urls?: Maybe<Array<Maybe<Scalars['String']>>>;
    datas?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_PushImpactOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryReleaseArgs

type QueryReleaseArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_ReleaseOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryRepoArgs

type QueryRepoArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    allowRebaseMerge?: Maybe<Scalars['Boolean']>;
    allowSquashMerge?: Maybe<Scalars['Boolean']>;
    allowMergeCommit?: Maybe<Scalars['Boolean']>;
    repoId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    defaultBranch?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    owners?: Maybe<Array<Maybe<Scalars['String']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    repoIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    gitHubIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    defaultBranchs?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_RepoFilter>;
};

type QueryResourceArgs

type QueryResourceArgs = {
    id?: Maybe<Scalars['ID']>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryResourceProviderArgs

type QueryResourceProviderArgs = {
    authProviderId?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['ID']>;
    orderBy?: Maybe<Array<Maybe<_ResourceProviderOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryResourceUserArgs

type QueryResourceUserArgs = {
    login?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['ID']>;
    _id?: Maybe<Scalars['Int']>;
};

type QueryReviewArgs

type QueryReviewArgs = {
    id?: Maybe<Scalars['ID']>;
    gitHubId?: Maybe<Scalars['String']>;
    reviewId?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<ReviewState>;
    submittedAt?: Maybe<Scalars['String']>;
    htmlUrl?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    gitHubIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    reviewIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    bodys?: Maybe<Array<Maybe<Scalars['String']>>>;
    states?: Maybe<Array<Maybe<ReviewState>>>;
    submittedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    htmlUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_ReviewOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryScmIdArgs

type QueryScmIdArgs = {
    id?: Maybe<Scalars['ID']>;
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    avatar?: Maybe<Scalars['String']>;
    logins?: Maybe<Array<Maybe<Scalars['String']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    avatars?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_ScmIdOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryScmProviderArgs

type QueryScmProviderArgs = {
    authProviderId?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['ID']>;
    private?: Maybe<Scalars['Boolean']>;
    url?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
    apiUrl?: Maybe<Scalars['String']>;
    gitUrl?: Maybe<Scalars['String']>;
    providerType?: Maybe<ProviderType>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    urls?: Maybe<Array<Maybe<Scalars['String']>>>;
    providerIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    apiUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    gitUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    providerTypes?: Maybe<Array<Maybe<ProviderType>>>;
    orderBy?: Maybe<Array<Maybe<_ScmProviderOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QuerySdmBuildIdentifierArgs

type QuerySdmBuildIdentifierArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    identifier?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type QuerySdmDeployEnablementArgs

type QuerySdmDeployEnablementArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    providerId?: Maybe<Array<Maybe<Scalars['String']>>>;
    repo?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<SdmDeployState>>>;
};

type QuerySdmGoalArgs

type QuerySdmGoalArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    _showHistory?: Maybe<Scalars['Boolean']>;
    approvalRequired?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
    branch?: Maybe<Array<Maybe<Scalars['String']>>>;
    data?: Maybe<Array<Maybe<Scalars['String']>>>;
    description?: Maybe<Array<Maybe<Scalars['String']>>>;
    environment?: Maybe<Array<Maybe<Scalars['String']>>>;
    error?: Maybe<Array<Maybe<Scalars['String']>>>;
    externalKey?: Maybe<Array<Maybe<Scalars['String']>>>;
    externalUrl?: Maybe<Array<Maybe<Scalars['String']>>>;
    goalSet?: Maybe<Array<Maybe<Scalars['String']>>>;
    goalSetId?: Maybe<Array<Maybe<Scalars['String']>>>;
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    parameters?: Maybe<Array<Maybe<Scalars['String']>>>;
    phase?: Maybe<Array<Maybe<Scalars['String']>>>;
    preApprovalRequired?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
    registration?: Maybe<Array<Maybe<Scalars['String']>>>;
    retryFeasible?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
    sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    signature?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<SdmGoalState>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
    uniqueName?: Maybe<Array<Maybe<Scalars['String']>>>;
    url?: Maybe<Array<Maybe<Scalars['String']>>>;
    version?: Maybe<Array<Maybe<Scalars['Int']>>>;
};

type QuerySdmGoalDisplayArgs

type QuerySdmGoalDisplayArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    branch?: Maybe<Array<Maybe<Scalars['String']>>>;
    format?: Maybe<Array<Maybe<SdmGoalDisplayFormat>>>;
    sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<SdmGoalDisplayState>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
};

type QuerySdmGoalSetArgs

type QuerySdmGoalSetArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    branch?: Maybe<Array<Maybe<Scalars['String']>>>;
    goalSet?: Maybe<Array<Maybe<Scalars['String']>>>;
    goalSetId?: Maybe<Array<Maybe<Scalars['String']>>>;
    sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<SdmGoalState>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
};

type QuerySdmGoalSetBadgeArgs

type QuerySdmGoalSetBadgeArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    sdm?: Maybe<Array<Maybe<Scalars['String']>>>;
    token?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type QuerySdmPreferenceArgs

type QuerySdmPreferenceArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    key?: Maybe<Array<Maybe<Scalars['String']>>>;
    ttl?: Maybe<Array<Maybe<Scalars['Int']>>>;
    value?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type QuerySdmRepoProvenanceArgs

type QuerySdmRepoProvenanceArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
};

type QuerySdmVersionArgs

type QuerySdmVersionArgs = {
    id?: Maybe<Scalars['ID']>;
    _offset?: Maybe<Scalars['Int']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _after?: Maybe<Scalars['Int']>;
    _before?: Maybe<Scalars['Int']>;
    _ordering?: Maybe<_Ordering>;
    _search?: Maybe<Scalars['String']>;
    branch?: Maybe<Array<Maybe<Scalars['String']>>>;
    sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    version?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type QuerySecretProviderArgs

type QuerySecretProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QuerySkillExecutionArgs

type QuerySkillExecutionArgs = {
    id: Scalars['ID'];
};

type QuerySkillExecutionsArgs

type QuerySkillExecutionsArgs = {
    _after?: Maybe<Scalars['String']>;
    _before?: Maybe<Scalars['String']>;
    _first?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<AtomistSkillExecutionSortField>;
    _ordering?: Maybe<AtomistSkillExecutionSortOrder>;
    filter?: Maybe<_AtomistSkillExecutionFilter>;
    name?: Maybe<Scalars['String']>;
    namespace?: Maybe<Scalars['String']>;
    version?: Maybe<Scalars['String']>;
    visibility?: Maybe<AtomistSkillExecutionVisibility>;
};

type QuerySourceFingerprintArgs

type QuerySourceFingerprintArgs = {
    name: Scalars['String'];
    sha: Scalars['String'];
    type: Scalars['String'];
};

type QueryStageArgs

type QueryStageArgs = {
    _id?: Maybe<Scalars['Int']>;
    name?: Maybe<Scalars['String']>;
};

type QueryStatusArgs

type QueryStatusArgs = {
    id?: Maybe<Scalars['ID']>;
    state?: Maybe<StatusState>;
    description?: Maybe<Scalars['String']>;
    targetUrl?: Maybe<Scalars['String']>;
    context?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    states?: Maybe<Array<Maybe<StatusState>>>;
    descriptions?: Maybe<Array<Maybe<Scalars['String']>>>;
    targetUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    contexts?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_StatusOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QuerySystemAccountArgs

type QuerySystemAccountArgs = {
    id?: Maybe<Scalars['ID']>;
    _id?: Maybe<Scalars['Int']>;
};

type QueryTagArgs

type QueryTagArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    ref?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    descriptions?: Maybe<Array<Maybe<Scalars['String']>>>;
    refs?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_TagOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_TagFilter>;
};

type QueryTeamArgs

type QueryTeamArgs = {
    id?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    iconUrl?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['String']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    descriptions?: Maybe<Array<Maybe<Scalars['String']>>>;
    iconUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    createdAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_TeamOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryTeamConfigurationArgs

type QueryTeamConfigurationArgs = {
    namespace?: Maybe<Scalars['String']>;
};

type QueryThrottledEventsReportArgs

type QueryThrottledEventsReportArgs = {
    bucketUnit?: Maybe<BucketUnit>;
    eventTypes?: Maybe<Array<EventType>>;
    from?: Maybe<Scalars['String']>;
    to?: Maybe<Scalars['String']>;
};

type QueryUserJoinedChannelArgs

type QueryUserJoinedChannelArgs = {
    id?: Maybe<Scalars['ID']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    orderBy?: Maybe<Array<Maybe<_UserJoinedChannelOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type QueryWebhookArgs

type QueryWebhookArgs = {
    id?: Maybe<Scalars['ID']>;
    resourceProviderId?: Maybe<Scalars['String']>;
};

type QueryWorkflowArgs

type QueryWorkflowArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    workflowId?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    config?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    workflowIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    providers?: Maybe<Array<Maybe<Scalars['String']>>>;
    configs?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_WorkflowOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type RegisteredAtomistSkill

type RegisteredAtomistSkill = AtomistSkill & {
    __typename?: 'RegisteredAtomistSkill';
    artifacts: Array<AtomistSkillArtifact>;
    author: Scalars['String'];
    capabilities: AtomistSkillCapabilitiesSpec;
    categories: Array<AtomistSkillCategory>;
    commands: Array<AtomistChatCommand>;
    createdAt: Scalars['String'];
    datalogSubscriptions?: Maybe<Array<AtomistSkillDatalogSubscription>>;
    description: Scalars['String'];
    dispatchStyle: AtomistSkillEventDispatchStyle;
    displayName?: Maybe<Scalars['String']>;
    homepageUrl: Scalars['String'];
    iconUrl: Scalars['String'];
    inCatalog: Scalars['Boolean'];
    ingesters: Array<Scalars['String']>;
    integration: Scalars['Boolean'];
    license: Scalars['String'];
    longDescription: Scalars['String'];
    maturities: Array<AtomistSkillMaturityLevel>;
    maxConfigurations: Scalars['Int'];
    name: Scalars['String'];
    namespace: Scalars['String'];
    owner: Scalars['Boolean'];
    parameters: Array<AtomistSkillParameterSpec>;
    platform: AtomistSkillExecutionPlatform;
    publishedAt?: Maybe<Scalars['String']>;
    readme?: Maybe<Scalars['String']>;
    resourceProviders?: Maybe<Array<AtomistSkillResourceProviderSpec>>;
    schemata?: Maybe<Array<AtomistSkillIngestionSchema>>;
    subscriptions: Array<Scalars['String']>;
    technologies: Array<AtomistSkillTechnology>;
    version: Scalars['String'];
    videoUrl?: Maybe<Scalars['String']>;
};

type Release

type Release = {
    __typename?: 'Release';
    _id?: Maybe<Scalars['Int']>;
    url?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['ID']>;
    gitHubId: Scalars['String'];
    name?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    action?: Maybe<ReleaseAction>;
    tag?: Maybe<Tag>;
};

type ReleaseTagArgs

type ReleaseTagArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    ref?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

type Repo

type Repo = {
    __typename?: 'Repo';
    _id?: Maybe<Scalars['Int']>;
    url?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    allowRebaseMerge?: Maybe<Scalars['Boolean']>;
    allowSquashMerge?: Maybe<Scalars['Boolean']>;
    allowMergeCommit?: Maybe<Scalars['Boolean']>;
    repoId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    defaultBranch?: Maybe<Scalars['String']>;
    labels?: Maybe<Array<Maybe<Label>>>;
    channels?: Maybe<Array<Maybe<ChatChannel>>>;
    org?: Maybe<Org>;
    issue?: Maybe<Array<Maybe<Issue>>>;
    issues?: Maybe<Array<Maybe<Issue>>>;
    pullRequest?: Maybe<Array<Maybe<PullRequest>>>;
    pullRequests?: Maybe<Array<Maybe<PullRequest>>>;
    pushes?: Maybe<Array<Maybe<Push>>>;
    /** Repo branches Branch */
    branches?: Maybe<Array<Maybe<Branch>>>;
    /** Repo links ChannelLink */
    links?: Maybe<Array<Maybe<ChannelLink>>>;
};

Repo-Node

type RepoBranchesArgs

type RepoBranchesArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    isRemote?: Maybe<Scalars['Boolean']>;
    orderBy?: Maybe<Array<Maybe<_BranchOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    remoteRepoHtmlUrl?: Maybe<Scalars['String']>;
};

Repo-Node

type RepoBranchTipsQuery

type RepoBranchTipsQuery = {
    __typename?: 'Query';
} & {
    Repo?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Repo';
                } & Pick<Repo, 'owner' | 'defaultBranch'> & {
                        org?: Maybe<
                            {
                                __typename?: 'Org';
                            } & {
                                provider?: Maybe<
                                    {
                                        __typename?: 'GitHubProvider';
                                    } & Pick<GitHubProvider, 'providerId'>
                                >;
                            }
                        >;
                        branches?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'Branch';
                                    } & Pick<Branch, 'name'> & {
                                            commit?: Maybe<
                                                {
                                                    __typename?: 'Commit';
                                                } & Pick<Commit, 'sha'>
                                            >;
                                        }
                                >
                            >
                        >;
                    }
            >
        >
    >;
};

type RepoBranchTipsQueryVariables

type RepoBranchTipsQueryVariables = {
    name: Scalars['String'];
    owner: Scalars['String'];
};

type RepoChannelsArgs

type RepoChannelsArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    normalizedName?: Maybe<Scalars['String']>;
    channelId?: Maybe<Scalars['String']>;
    isDefault?: Maybe<Scalars['Boolean']>;
    botInvitedSelf?: Maybe<Scalars['Boolean']>;
    orderBy?: Maybe<Array<Maybe<_ChatChannelOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    archived?: Maybe<Scalars['Boolean']>;
};

Repo-Node

type RepoCreationListener

type RepoCreationListener = SdmListener<RepoCreationListenerInvocation>;

Respond to the creation of a new repo. Note that it may not have code in it, so you may want to use a PushListener! See SoftwareDeliveryMachine.addFirstPushListener

type RepoIssueArgs

type RepoIssueArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    name?: Maybe<Scalars['String']>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    title?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<IssueState>;
    timestamp?: Maybe<Scalars['String']>;
    action?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_IssueOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    closedAt?: Maybe<Scalars['String']>;
};

Repo-Node

type RepoIssuesArgs

type RepoIssuesArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    name?: Maybe<Scalars['String']>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    title?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<IssueState>;
    timestamp?: Maybe<Scalars['String']>;
    action?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_IssueOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    closedAt?: Maybe<Scalars['String']>;
};

Repo-Node

type RepoLabelsArgs

type RepoLabelsArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    default?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_LabelOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    color?: Maybe<Scalars['String']>;
};

Repo-Node

type RepoLinksArgs

type RepoLinksArgs = {
    orderBy?: Maybe<Array<Maybe<_ChannelLinkOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
};

Repo-Node

type RepoListener

type RepoListener<
    I extends RepoListenerInvocation = RepoListenerInvocation,
    R extends any = any
> = Function1<I, Promise<R>>;

type RepoListenerInvocation

type RepoListenerInvocation = RepoContext;

Common parameters to an invocation of a listener to one of the SDM's specific events. These are fired by our event handlers to allow multiple, domain specific, listeners to be invoked.

type RepoLogin

type RepoLogin = {
    __typename?: 'RepoLogin';
    /** The repository name */
    repo?: Maybe<Scalars['String']>;
    /** The owner name for the Organization/Team */
    owner?: Maybe<Scalars['String']>;
    /** The id of the git provider for this Owner */
    providerId?: Maybe<Scalars['String']>;
    /** The login that should be used */
    login?: Maybe<Scalars['String']>;
};

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

type RepoOnboarded

type RepoOnboarded = {
    __typename?: 'RepoOnboarded';
    /** GitHub Repository */
    repo: Repo;
};

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

type RepoOrgArgs

type RepoOrgArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    ownerType?: Maybe<OwnerType>;
};

Repo-Node

type RepoPullRequestArgs

type RepoPullRequestArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    prId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    merged?: Maybe<Scalars['Boolean']>;
    timestamp?: Maybe<Scalars['String']>;
    baseBranchName?: Maybe<Scalars['String']>;
    branchName?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    closedAt?: Maybe<Scalars['String']>;
    mergedAt?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_PullRequestOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    mergeStatus?: Maybe<MergeStatus>;
};

Repo-Node

type RepoPullRequestsArgs

type RepoPullRequestsArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    prId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    merged?: Maybe<Scalars['Boolean']>;
    timestamp?: Maybe<Scalars['String']>;
    baseBranchName?: Maybe<Scalars['String']>;
    branchName?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    closedAt?: Maybe<Scalars['String']>;
    mergedAt?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_PullRequestOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    mergeStatus?: Maybe<MergeStatus>;
};

Repo-Node

type RepoPushesArgs

type RepoPushesArgs = {
    name?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_PushOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

Repo-Node

type ReportProgress

type ReportProgress = (log: string, sdmGoal: SdmGoalEvent) => Progress;

Report on the Progress of a Goal execution based on given log extract. Usually this is the most current log line produced by the Goal execution.
The returned Progress.phase will be stored on the Goal and overridden when a new phase has been reported.
If the goal fails, the failing phase is preserved. In all other cases the phase will be reset on goal completion.

type RepoScmProviderQuery

type RepoScmProviderQuery = {
    __typename?: 'Query';
} & {
    Repo?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Repo';
                } & Pick<Repo, 'defaultBranch' | 'name' | 'owner'> & {
                        branches?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'Branch';
                                    } & Pick<Branch, 'name'>
                                >
                            >
                        >;
                        org?: Maybe<
                            {
                                __typename?: 'Org';
                            } & Pick<Org, 'owner' | 'ownerType'> & {
                                    scmProvider?: Maybe<
                                        {
                                            __typename?: 'SCMProvider';
                                        } & ScmProviderFieldsFragment
                                    >;
                                }
                        >;
                    }
            >
        >
    >;
};

type RepoScmProviderQueryVariables

type RepoScmProviderQueryVariables = {
    repo: Scalars['String'];
    owner: Scalars['String'];
};

type ReposInTeamQuery

type ReposInTeamQuery = {
    __typename?: 'Query';
} & {
    ChatTeam?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'ChatTeam';
                } & {
                    orgs?: Maybe<
                        Array<
                            Maybe<
                                {
                                    __typename?: 'Org';
                                } & {
                                    repo?: Maybe<
                                        Array<
                                            Maybe<
                                                {
                                                    __typename?: 'Repo';
                                                } & Pick<Repo, 'name' | 'owner'> & {
                                                        org?: Maybe<
                                                            {
                                                                __typename?: 'Org';
                                                            } & {
                                                                provider?: Maybe<
                                                                    {
                                                                        __typename?: 'GitHubProvider';
                                                                    } & Pick<
                                                                        GitHubProvider,
                                                                        | 'providerType'
                                                                        | 'apiUrl'
                                                                    >
                                                                >;
                                                            }
                                                        >;
                                                    }
                                            >
                                        >
                                    >;
                                }
                            >
                        >
                    >;
                }
            >
        >
    >;
};

type ReposInTeamQueryVariables

type ReposInTeamQueryVariables = {
    offset: Scalars['Int'];
    size: Scalars['Int'];
};

type RepositoryByOwnerAndNameQuery

type RepositoryByOwnerAndNameQuery = {
    __typename?: 'Query';
} & {
    Repo?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Repo';
                } & Pick<Repo, 'id' | 'name' | 'owner'> & {
                        org?: Maybe<
                            {
                                __typename?: 'Org';
                            } & {
                                provider?: Maybe<
                                    {
                                        __typename?: 'GitHubProvider';
                                    } & Pick<
                                        GitHubProvider,
                                        | 'providerId'
                                        | 'providerType'
                                        | 'apiUrl'
                                        | 'url'
                                    >
                                >;
                            }
                        >;
                    }
            >
        >
    >;
};

type RepositoryByOwnerAndNameQueryVariables

type RepositoryByOwnerAndNameQueryVariables = {
    owner?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
};

type RepositoryMappedChannelsQuery

type RepositoryMappedChannelsQuery = {
    __typename?: 'Query';
} & {
    ChatChannel?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'ChatChannel';
                } & {
                    repos?: Maybe<
                        Array<
                            Maybe<
                                {
                                    __typename?: 'Repo';
                                } & Pick<Repo, 'id' | 'name' | 'owner'> & {
                                        org?: Maybe<
                                            {
                                                __typename?: 'Org';
                                            } & {
                                                provider?: Maybe<
                                                    {
                                                        __typename?: 'GitHubProvider';
                                                    } & Pick<
                                                        GitHubProvider,
                                                        | 'providerId'
                                                        | 'providerType'
                                                        | 'apiUrl'
                                                        | 'url'
                                                    >
                                                >;
                                            }
                                        >;
                                    }
                            >
                        >
                    >;
                }
            >
        >
    >;
};

type RepositoryMappedChannelsQueryVariables

type RepositoryMappedChannelsQueryVariables = {
    id: Scalars['String'];
};

type Resource

type Resource = {
    id: Scalars['ID'];
    _id: Scalars['Int'];
};

type ResourceLinks

type ResourceLinks = {
    pushLink?: Maybe<PushLink>;
    commitLink?: Maybe<CommitLink>;
};

type ResourceProvider

type ResourceProvider = {
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    _id: Scalars['Int'];
    id: Scalars['ID'];
    name?: Maybe<Scalars['String']>;
    team: Team;
    authProviderId?: Maybe<Scalars['String']>;
    state?: Maybe<ResourceProviderState>;
    credential?: Maybe<Credential>;
    webhooks?: Maybe<Array<Maybe<Webhook>>>;
    createdAt: Scalars['String'];
    updatedAt: Scalars['String'];
    createdBy?: Maybe<Person>;
    updatedBy?: Maybe<Person>;
    metadata?: Maybe<ResourceProviderMetadata>;
};

type ResourceProviderMetadata

type ResourceProviderMetadata = {
    __typename?: 'ResourceProviderMetadata';
    /** The 20 most recenetly receieved events to this ResourceProvider */
    events: Array<Scalars['String']>;
    /** A timestamp of when we last received an event on this ResourceProvider */
    eventLastReceived?: Maybe<Scalars['String']>;
};

type ResourceProviderState

type ResourceProviderState = {
    __typename?: 'ResourceProviderState';
    error?: Maybe<Scalars['String']>;
    name?: Maybe<ResourceProviderStateName>;
};

type ResourceProviderStateInput

type ResourceProviderStateInput = {
    state: ResourceProviderStateName;
    error?: Maybe<Scalars['String']>;
};

type ResourceProviderWebhooksArgs

type ResourceProviderWebhooksArgs = {
    id?: Maybe<Scalars['ID']>;
};

type ResourceUser

type ResourceUser = {
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    id: Scalars['ID'];
    _id?: Maybe<Scalars['Int']>;
    credential?: Maybe<Credential>;
    provider: ResourceProvider;
    login: Scalars['String'];
};

type ResourceUserProviderArgs

type ResourceUserProviderArgs = {
    id?: Maybe<Scalars['ID']>;
};

type ResourceUserQuery

type ResourceUserQuery = {
    __typename?: 'Query';
} & {
    ChatId?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'ChatId';
                } & {
                    person?: Maybe<
                        {
                            __typename?: 'Person';
                        } & {
                            gitHubId?: Maybe<
                                {
                                    __typename?: 'GitHubId';
                                } & Pick<GitHubId, 'login'> & {
                                        credential?: Maybe<
                                            {
                                                __typename?: 'OAuthToken';
                                            } & Pick<OAuthToken, 'secret' | 'scopes'>
                                        >;
                                    }
                            >;
                        }
                    >;
                }
            >
        >
    >;
};

type ResourceUserQueryVariables

type ResourceUserQueryVariables = {
    id: Scalars['String'];
};

type ResumeJobMutation

type ResumeJobMutation = {
    __typename?: 'Mutation';
} & {
    resumeAtmJob?: Maybe<
        {
            __typename?: 'AtmJob';
        } & Pick<AtmJob, 'id'>
    >;
};

type ResumeJobMutationVariables

type ResumeJobMutationVariables = {
    id: Scalars['String'];
};

type Review

type Review = {
    __typename?: 'Review';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** the URL of the Review */
    url?: Maybe<Scalars['String']>;
    /** id of  Review */
    id?: Maybe<Scalars['ID']>;
    /** gitHubId of  Review */
    gitHubId?: Maybe<Scalars['String']>;
    /** reviewId of  Review */
    reviewId?: Maybe<Scalars['String']>;
    /** body of  Review */
    body?: Maybe<Scalars['String']>;
    /** state of  Review */
    state?: Maybe<ReviewState>;
    /** submittedAt of  Review */
    submittedAt?: Maybe<Scalars['String']>;
    /** htmlUrl of  Review */
    htmlUrl?: Maybe<Scalars['String']>;
    /** Review by SCMId */
    by?: Maybe<Array<Maybe<ScmId>>>;
    /** Review commit Commit */
    commit?: Maybe<Commit>;
    /** Review comments Comment */
    comments?: Maybe<Array<Maybe<Comment>>>;
    /** Review pullRequest PullRequest */
    pullRequest?: Maybe<PullRequest>;
};

Review-Node

type ReviewByArgs

type ReviewByArgs = {
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_ScmIdOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    avatar?: Maybe<Scalars['String']>;
    filter?: Maybe<_ScmIdFilter>;
};

Review-Node

type ReviewCommentsArgs

type ReviewCommentsArgs = {
    id?: Maybe<Scalars['ID']>;
    body?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    commentId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    path?: Maybe<Scalars['String']>;
    position?: Maybe<Scalars['String']>;
    htmlUrl?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_CommentOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    commentType?: Maybe<CommentCommentType>;
};

Review-Node

type ReviewCommitArgs

type ReviewCommitArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

Review-Node

type ReviewListener

type ReviewListener = SdmListener<
    ReviewListenerInvocation,
    void | PushImpactResponse
>;

Listener invoked when a review has been completed. Listeners will be invoked even in the case of a clean review, without errors or comments.

type ReviewPullRequestArgs

type ReviewPullRequestArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    prId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    merged?: Maybe<Scalars['Boolean']>;
    timestamp?: Maybe<Scalars['String']>;
    baseBranchName?: Maybe<Scalars['String']>;
    branchName?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    closedAt?: Maybe<Scalars['String']>;
    mergedAt?: Maybe<Scalars['String']>;
    mergeStatus?: Maybe<MergeStatus>;
};

Review-Node

type Scalars

type Scalars = {
    ID: string;
    String: string;
    Boolean: boolean;
    Int: number;
    Float: number;
};

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

type ScmAuthorInput

type ScmAuthorInput = {
    /** The login of the commit author in the SCM provider */
    login: Scalars['String'];
    /** The authors email address */
    email?: Maybe<EmailInput>;
    /** The name of the author */
    name?: Maybe<Scalars['String']>;
};

type ScmCommitInput

type ScmCommitInput = {
    /** The id of the repo as it appears in the graph */
    repoId: Scalars['String'];
    /** The sha of the commit */
    sha: Scalars['String'];
    /** The email address of the commit */
    email?: Maybe<EmailInput>;
    /** The commit message */
    message: Scalars['String'];
    /** The http url of the commit in the SCM provider */
    url?: Maybe<Scalars['String']>;
    /** The commit timestamp */
    timestamp: Scalars['String'];
    /** The name of the branch this commit is being ingested on */
    branchName: Scalars['String'];
    /** The author of the commit - optional but helpful if available */
    author?: Maybe<ScmAuthorInput>;
};

type ScmId

type ScmId = ResourceUser & {
    __typename?: 'SCMId';
    /** name of  SCMId */
    name?: Maybe<Scalars['String']>;
    /** avatar of  SCMId */
    avatar?: Maybe<Scalars['String']>;
    credential?: Maybe<OAuthToken>;
    provider: ScmProvider;
    /** SCMId emails Email */
    emails?: Maybe<Array<Maybe<Email>>>;
    /** SCMId person Person */
    person?: Maybe<Person>;
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    id: Scalars['ID'];
    _id?: Maybe<Scalars['Int']>;
    login: Scalars['String'];
};

SCMId-Node

type ScmIdEmailsArgs

type ScmIdEmailsArgs = {
    orderBy?: Maybe<Array<Maybe<_EmailOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    address?: Maybe<Scalars['String']>;
};

SCMId-Node

type ScmIdPersonArgs

type ScmIdPersonArgs = {
    id?: Maybe<Scalars['ID']>;
    forename?: Maybe<Scalars['String']>;
    surname?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
};

SCMId-Node

type ScmIdProviderArgs

type ScmIdProviderArgs = {
    id?: Maybe<Scalars['ID']>;
};

SCMId-Node

type ScmOrgInput

type ScmOrgInput = {
    name: Scalars['String'];
    id?: Maybe<Scalars['String']>;
    url?: Maybe<Scalars['String']>;
    ownerType: OwnerType;
};

type ScmOrgsInput

type ScmOrgsInput = {
    orgs: Array<ScmOrgInput>;
};

type ScmProvider

type ScmProvider = ResourceProvider & {
    __typename?: 'SCMProvider';
    url?: Maybe<Scalars['String']>;
    providerId: Scalars['String'];
    private?: Maybe<Scalars['Boolean']>;
    apiUrl: Scalars['String'];
    gitUrl: Scalars['String'];
    providerType?: Maybe<ProviderType>;
    targetConfiguration?: Maybe<ScmProviderSpec>;
    orgs?: Maybe<Array<Maybe<Org>>>;
    credential?: Maybe<OAuthToken>;
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    _id: Scalars['Int'];
    id: Scalars['ID'];
    name?: Maybe<Scalars['String']>;
    team: Team;
    authProviderId?: Maybe<Scalars['String']>;
    state?: Maybe<ResourceProviderState>;
    webhooks?: Maybe<Array<Maybe<Webhook>>>;
    createdAt: Scalars['String'];
    updatedAt: Scalars['String'];
    createdBy?: Maybe<Person>;
    updatedBy?: Maybe<Person>;
    metadata?: Maybe<ResourceProviderMetadata>;
};

SCMProvider-Node

type ScmProviderByTypeQuery

type ScmProviderByTypeQuery = {
    __typename?: 'Query';
} & {
    SCMProvider?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SCMProvider';
                } & Pick<ScmProvider, 'providerId' | 'apiUrl'> & {
                        credential?: Maybe<
                            {
                                __typename?: 'OAuthToken';
                            } & Pick<OAuthToken, 'secret'>
                        >;
                    }
            >
        >
    >;
};

type ScmProviderByTypeQueryVariables

type ScmProviderByTypeQueryVariables = {
    providerType: ProviderType;
};

type ScmProviderFieldsFragment

type ScmProviderFieldsFragment = {
    __typename?: 'SCMProvider';
} & Pick<ScmProvider, 'apiUrl' | 'providerId' | 'providerType' | 'url'> & {
        credential?: Maybe<
            {
                __typename?: 'OAuthToken';
            } & Pick<OAuthToken, 'secret'>
        >;
    };

type ScmProviderOrgsArgs

type ScmProviderOrgsArgs = {
    owner?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_OrgOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    ownerType?: Maybe<OwnerType>;
};

SCMProvider-Node

type ScmProviderQuery

type ScmProviderQuery = {
    __typename?: 'Query';
} & {
    SCMProvider?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SCMProvider';
                } & Pick<
                    ScmProvider,
                    'providerType' | 'url' | 'providerId' | 'apiUrl'
                > & {
                        credential?: Maybe<
                            {
                                __typename?: 'OAuthToken';
                            } & Pick<OAuthToken, 'secret'>
                        >;
                    }
            >
        >
    >;
};

type ScmProviderQueryVariables

type ScmProviderQueryVariables = {
    providerId: Scalars['String'];
};

type ScmProviderRepoSpec

type ScmProviderRepoSpec = {
    __typename?: 'SCMProviderRepoSpec';
    ownerSpec: Scalars['String'];
    nameSpec: Scalars['String'];
};

type ScmProviderSpec

type ScmProviderSpec = {
    __typename?: 'SCMProviderSpec';
    orgSpecs: Array<Scalars['String']>;
    repoSpecs: Array<ScmProviderRepoSpec>;
};

type ScmProvidersQuery

type ScmProvidersQuery = {
    __typename?: 'Query';
} & {
    SCMProvider?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SCMProvider';
                } & ScmProviderFieldsFragment
            >
        >
    >;
};

type ScmProvidersQueryVariables

type ScmProvidersQueryVariables = {};

type ScmProviderStateInput

type ScmProviderStateInput = {
    state: ScmProviderStateName;
    error?: Maybe<Scalars['String']>;
};

type ScmProviderWebhooksArgs

type ScmProviderWebhooksArgs = {
    id?: Maybe<Scalars['ID']>;
};

SCMProvider-Node

type ScmRepoInput

type ScmRepoInput = {
    /** The the id of the repo as provided by the SCM provider not the Atomist graph */
    repoId: Scalars['String'];
    /** The http url of the repo in the SCM provider */
    url?: Maybe<Scalars['String']>;
    /** The name of the repo */
    name: Scalars['String'];
    /** The default branch of the repo (master if unknown) */
    defaultBranch?: Maybe<Scalars['String']>;
};

type ScmReposInput

type ScmReposInput = {
    /** The id of the org as represented in the Atomist graph */
    orgId: Scalars['String'];
    owner: Scalars['String'];
    /** The list of repos to ingest */
    repos: Array<ScmRepoInput>;
};

type ScmResourceProviderInput

type ScmResourceProviderInput = {
    orgs: Array<Scalars['String']>;
    repos: Array<ScmResourceProviderRepoInput>;
};

type ScmResourceProviderRepoInput

type ScmResourceProviderRepoInput = {
    owner: Scalars['String'];
    repo: Scalars['String'];
};

type SdmBuildIdentifier

type SdmBuildIdentifier = {
    __typename?: 'SdmBuildIdentifier';
    identifier?: Maybe<Scalars['String']>;
    repo?: Maybe<SdmBuildIdentifierRepository>;
    /** The ID of this SdmBuildIdentifier */
    id?: Maybe<Scalars['ID']>;
};

type SdmBuildIdentifierRepoArgs

type SdmBuildIdentifierRepoArgs = {
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    providerId?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SdmBuildIdentifierRepository

type SdmBuildIdentifierRepository = {
    __typename?: 'SdmBuildIdentifierRepository';
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
};

type SdmCondition

type SdmCondition = {
    __typename?: 'SdmCondition';
    environment?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    uniqueName?: Maybe<Scalars['String']>;
};

type SdmDeployEnablement

type SdmDeployEnablement = {
    __typename?: 'SdmDeployEnablement';
    owner?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
    repo?: Maybe<Scalars['String']>;
    state?: Maybe<SdmDeployState>;
    /** The ID of this SdmDeployEnablement */
    id?: Maybe<Scalars['ID']>;
};

type SdmExternalUrl

type SdmExternalUrl = {
    __typename?: 'SdmExternalUrl';
    label?: Maybe<Scalars['String']>;
    url?: Maybe<Scalars['String']>;
};

type SdmGoal

type SdmGoal = {
    __typename?: 'SdmGoal';
    approval?: Maybe<SdmProvenance>;
    approvalRequired?: Maybe<Scalars['Boolean']>;
    branch?: Maybe<Scalars['String']>;
    data?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    descriptions?: Maybe<SdmGoalDescriptions>;
    environment?: Maybe<Scalars['String']>;
    error?: Maybe<Scalars['String']>;
    externalKey?: Maybe<Scalars['String']>;
    externalUrl?: Maybe<Scalars['String']>;
    externalUrls?: Maybe<Array<Maybe<SdmExternalUrl>>>;
    fulfillment?: Maybe<SdmGoalFulfillment>;
    goalSet?: Maybe<Scalars['String']>;
    goalSetId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    parameters?: Maybe<Scalars['String']>;
    phase?: Maybe<Scalars['String']>;
    preApproval?: Maybe<SdmProvenance>;
    preApprovalRequired?: Maybe<Scalars['Boolean']>;
    preConditions?: Maybe<Array<Maybe<SdmCondition>>>;
    provenance?: Maybe<Array<Maybe<SdmProvenance>>>;
    push?: Maybe<Push>;
    registration?: Maybe<Scalars['String']>;
    repo?: Maybe<SdmRepository>;
    retryFeasible?: Maybe<Scalars['Boolean']>;
    sha?: Maybe<Scalars['String']>;
    signature?: Maybe<Scalars['String']>;
    state?: Maybe<SdmGoalState>;
    ts?: Maybe<Scalars['Int']>;
    uniqueName?: Maybe<Scalars['String']>;
    url?: Maybe<Scalars['String']>;
    version?: Maybe<Scalars['Int']>;
    /** The ID of this SdmGoal */
    id?: Maybe<Scalars['ID']>;
};

type SdmGoalByShaAndBranchQuery

type SdmGoalByShaAndBranchQuery = {
    __typename?: 'Query';
} & {
    SdmGoal?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SdmGoal';
                } & Pick<
                    SdmGoal,
                    | 'goalSet'
                    | 'registration'
                    | 'goalSetId'
                    | 'environment'
                    | 'uniqueName'
                    | 'name'
                    | 'sha'
                    | 'branch'
                    | 'description'
                    | 'url'
                    | 'externalUrl'
                    | 'state'
                    | 'externalKey'
                    | 'ts'
                    | 'error'
                    | 'retryFeasible'
                    | 'parameters'
                    | 'data'
                    | 'version'
                    | 'signature'
                > & {
                        repo?: Maybe<
                            {
                                __typename?: 'SdmRepository';
                            } & Pick<SdmRepository, 'name' | 'owner' | 'providerId'>
                        >;
                        fulfillment?: Maybe<
                            {
                                __typename?: 'SdmGoalFulfillment';
                            } & Pick<
                                SdmGoalFulfillment,
                                'method' | 'registration' | 'name'
                            >
                        >;
                        externalUrls?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'SdmExternalUrl';
                                    } & Pick<SdmExternalUrl, 'label' | 'url'>
                                >
                            >
                        >;
                        preConditions?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'SdmCondition';
                                    } & Pick<SdmCondition, 'environment' | 'name'>
                                >
                            >
                        >;
                        approval?: Maybe<
                            {
                                __typename?: 'SdmProvenance';
                            } & Pick<
                                SdmProvenance,
                                | 'correlationId'
                                | 'registration'
                                | 'name'
                                | 'version'
                                | 'ts'
                                | 'userId'
                                | 'channelId'
                            >
                        >;
                        preApproval?: Maybe<
                            {
                                __typename?: 'SdmProvenance';
                            } & Pick<
                                SdmProvenance,
                                | 'correlationId'
                                | 'registration'
                                | 'name'
                                | 'version'
                                | 'ts'
                                | 'userId'
                                | 'channelId'
                            >
                        >;
                        provenance?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'SdmProvenance';
                                    } & Pick<
                                        SdmProvenance,
                                        | 'correlationId'
                                        | 'registration'
                                        | 'name'
                                        | 'version'
                                        | 'ts'
                                        | 'userId'
                                        | 'channelId'
                                    >
                                >
                            >
                        >;
                        descriptions?: Maybe<
                            {
                                __typename?: 'SdmGoalDescriptions';
                            } & Pick<
                                SdmGoalDescriptions,
                                | 'canceled'
                                | 'completed'
                                | 'failed'
                                | 'inProcess'
                                | 'planned'
                                | 'requested'
                                | 'stopped'
                                | 'waitingForApproval'
                                | 'waitingForPreApproval'
                            >
                        >;
                    }
            >
        >
    >;
};

type SdmGoalByShaAndBranchQueryVariables

type SdmGoalByShaAndBranchQueryVariables = {
    repo: Scalars['String'];
    owner: Scalars['String'];
    providerId: Scalars['String'];
    sha: Scalars['String'];
    branch: Scalars['String'];
    uniqueNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SdmGoalDescriptions

type SdmGoalDescriptions = {
    __typename?: 'SdmGoalDescriptions';
    canceled?: Maybe<Scalars['String']>;
    completed?: Maybe<Scalars['String']>;
    failed?: Maybe<Scalars['String']>;
    inProcess?: Maybe<Scalars['String']>;
    planned?: Maybe<Scalars['String']>;
    requested?: Maybe<Scalars['String']>;
    skipped?: Maybe<Scalars['String']>;
    stopped?: Maybe<Scalars['String']>;
    waitingForApproval?: Maybe<Scalars['String']>;
    waitingForPreApproval?: Maybe<Scalars['String']>;
};

type SdmGoalDisplay

type SdmGoalDisplay = {
    __typename?: 'SdmGoalDisplay';
    branch?: Maybe<Scalars['String']>;
    format?: Maybe<SdmGoalDisplayFormat>;
    push?: Maybe<Push>;
    repo?: Maybe<SdmRepository>;
    sha?: Maybe<Scalars['String']>;
    state?: Maybe<SdmGoalDisplayState>;
    ts?: Maybe<Scalars['Int']>;
    /** The ID of this SdmGoalDisplay */
    id?: Maybe<Scalars['ID']>;
};

type SdmGoalFieldsFragment

type SdmGoalFieldsFragment = {
    __typename?: 'SdmGoal';
} & Pick<
    SdmGoal,
    | 'environment'
    | 'uniqueName'
    | 'name'
    | 'sha'
    | 'branch'
    | 'description'
    | 'url'
    | 'externalUrl'
    | 'state'
    | 'phase'
    | 'externalKey'
    | 'goalSet'
    | 'registration'
    | 'goalSetId'
    | 'ts'
    | 'error'
    | 'retryFeasible'
    | 'approvalRequired'
    | 'preApprovalRequired'
    | 'parameters'
    | 'data'
    | 'version'
    | 'signature'
> & {
        fulfillment?: Maybe<
            {
                __typename?: 'SdmGoalFulfillment';
            } & Pick<SdmGoalFulfillment, 'method' | 'registration' | 'name'>
        >;
        externalUrls?: Maybe<
            Array<
                Maybe<
                    {
                        __typename?: 'SdmExternalUrl';
                    } & Pick<SdmExternalUrl, 'label' | 'url'>
                >
            >
        >;
        preConditions?: Maybe<
            Array<
                Maybe<
                    {
                        __typename?: 'SdmCondition';
                    } & Pick<SdmCondition, 'environment' | 'uniqueName' | 'name'>
                >
            >
        >;
        approval?: Maybe<
            {
                __typename?: 'SdmProvenance';
            } & Pick<
                SdmProvenance,
                | 'correlationId'
                | 'registration'
                | 'name'
                | 'version'
                | 'ts'
                | 'userId'
                | 'channelId'
            >
        >;
        preApproval?: Maybe<
            {
                __typename?: 'SdmProvenance';
            } & Pick<
                SdmProvenance,
                | 'correlationId'
                | 'registration'
                | 'name'
                | 'version'
                | 'ts'
                | 'userId'
                | 'channelId'
            >
        >;
        provenance?: Maybe<
            Array<
                Maybe<
                    {
                        __typename?: 'SdmProvenance';
                    } & Pick<
                        SdmProvenance,
                        | 'correlationId'
                        | 'registration'
                        | 'name'
                        | 'version'
                        | 'ts'
                        | 'userId'
                        | 'channelId'
                    >
                >
            >
        >;
        descriptions?: Maybe<
            {
                __typename?: 'SdmGoalDescriptions';
            } & Pick<
                SdmGoalDescriptions,
                | 'canceled'
                | 'completed'
                | 'failed'
                | 'inProcess'
                | 'planned'
                | 'requested'
                | 'stopped'
                | 'skipped'
                | 'waitingForApproval'
                | 'waitingForPreApproval'
            >
        >;
        push?: Maybe<
            {
                __typename?: 'Push';
            } & PushFieldsFragment
        >;
    };

type SdmGoalFulfillment

type SdmGoalFulfillment = {
    __typename?: 'SdmGoalFulfillment';
    method?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    registration?: Maybe<Scalars['String']>;
};

type SdmGoalFulfillmentArgs

type SdmGoalFulfillmentArgs = {
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    method?: Maybe<Array<Maybe<Scalars['String']>>>;
    registration?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SdmGoalName

type SdmGoalName = {
    __typename?: 'SdmGoalName';
    name?: Maybe<Scalars['String']>;
    uniqueName?: Maybe<Scalars['String']>;
};

type SdmGoalProvenanceArgs

type SdmGoalProvenanceArgs = {
    registration?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SdmGoalRepoArgs

type SdmGoalRepoArgs = {
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    providerId?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SdmGoalRepoFragment

type SdmGoalRepoFragment = {
    __typename?: 'SdmGoal';
} & {
    repo?: Maybe<
        {
            __typename?: 'SdmRepository';
        } & Pick<SdmRepository, 'name' | 'owner' | 'providerId'>
    >;
};

type SdmGoalsByGoalSetIdAndUniqueNameQuery

type SdmGoalsByGoalSetIdAndUniqueNameQuery = {
    __typename?: 'Query';
} & {
    SdmGoal?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SdmGoal';
                } & SdmGoalFieldsFragment &
                    SdmGoalRepoFragment
            >
        >
    >;
};

type SdmGoalsByGoalSetIdAndUniqueNameQueryVariables

type SdmGoalsByGoalSetIdAndUniqueNameQueryVariables = {
    goalSetId?: Maybe<Array<Scalars['String']>>;
    uniqueName?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SdmGoalSet

type SdmGoalSet = {
    __typename?: 'SdmGoalSet';
    branch?: Maybe<Scalars['String']>;
    goalSet?: Maybe<Scalars['String']>;
    goalSetId?: Maybe<Scalars['String']>;
    goals?: Maybe<Array<Maybe<SdmGoalName>>>;
    provenance?: Maybe<SdmProvenance>;
    push?: Maybe<Push>;
    repo?: Maybe<SdmRepository>;
    sha?: Maybe<Scalars['String']>;
    state?: Maybe<SdmGoalState>;
    tags?: Maybe<Array<Maybe<SdmGoalSetTag>>>;
    ts?: Maybe<Scalars['Int']>;
    /** The ID of this SdmGoalSet */
    id?: Maybe<Scalars['ID']>;
};

type SdmGoalSetBadge

type SdmGoalSetBadge = {
    __typename?: 'SdmGoalSetBadge';
    repo?: Maybe<SdmGoalSetBadgeRepository>;
    sdm?: Maybe<Scalars['String']>;
    token?: Maybe<Scalars['String']>;
    /** The ID of this SdmGoalSetBadge */
    id?: Maybe<Scalars['ID']>;
};

type SdmGoalSetBadgeRepoArgs

type SdmGoalSetBadgeRepoArgs = {
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    providerId?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SdmGoalSetBadgeRepository

type SdmGoalSetBadgeRepository = {
    __typename?: 'SdmGoalSetBadgeRepository';
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
};

type SdmGoalSetFieldsFragment

type SdmGoalSetFieldsFragment = {
    __typename?: 'SdmGoalSet';
} & Pick<SdmGoalSet, 'sha' | 'branch' | 'goalSet' | 'goalSetId' | 'state' | 'ts'> & {
        goals?: Maybe<
            Array<
                Maybe<
                    {
                        __typename?: 'SdmGoalName';
                    } & Pick<SdmGoalName, 'name' | 'uniqueName'>
                >
            >
        >;
        provenance?: Maybe<
            {
                __typename?: 'SdmProvenance';
            } & Pick<
                SdmProvenance,
                | 'channelId'
                | 'correlationId'
                | 'name'
                | 'registration'
                | 'ts'
                | 'userId'
                | 'version'
            >
        >;
        repo?: Maybe<
            {
                __typename?: 'SdmRepository';
            } & Pick<SdmRepository, 'name' | 'owner' | 'providerId'>
        >;
        tags?: Maybe<
            Array<
                Maybe<
                    {
                        __typename?: 'SdmGoalSetTag';
                    } & Pick<SdmGoalSetTag, 'name' | 'value'>
                >
            >
        >;
    };

type SdmGoalSetForIdQuery

type SdmGoalSetForIdQuery = {
    __typename?: 'Query';
} & {
    SdmGoalSet?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SdmGoalSet';
                } & SdmGoalSetFieldsFragment
            >
        >
    >;
};

type SdmGoalSetForIdQueryVariables

type SdmGoalSetForIdQueryVariables = {
    goalSetId?: Maybe<Array<Scalars['String']>>;
};

type SdmGoalSetProvenanceArgs

type SdmGoalSetProvenanceArgs = {
    registration?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SdmGoalSetRepoArgs

type SdmGoalSetRepoArgs = {
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    providerId?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SdmGoalSetTag

type SdmGoalSetTag = {
    __typename?: 'SdmGoalSetTag';
    name?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
};

type SdmGoalsForCommitQuery

type SdmGoalsForCommitQuery = {
    __typename?: 'Query';
} & {
    SdmGoal?: Maybe<
        Array<
            Maybe<
                ({
                    __typename?: 'SdmGoal';
                } & Pick<SdmGoal, 'id'> & {
                        repo?: Maybe<
                            {
                                __typename?: 'SdmRepository';
                            } & Pick<SdmRepository, 'name' | 'owner' | 'providerId'>
                        >;
                    }) &
                    SdmGoalFieldsFragment
            >
        >
    >;
};

type SdmGoalsForCommitQueryVariables

type SdmGoalsForCommitQueryVariables = {
    sha: Scalars['String'];
    branch?: Maybe<Scalars['String']>;
    repo: Scalars['String'];
    owner: Scalars['String'];
    providerId: Scalars['String'];
    goalSetId?: Maybe<Scalars['String']>;
    qty: Scalars['Int'];
    offset: Scalars['Int'];
};

type SdmGoalWithGoalsFieldsFragment

type SdmGoalWithGoalsFieldsFragment = {
    __typename?: 'SdmGoal';
} & Pick<
    SdmGoal,
    | 'environment'
    | 'uniqueName'
    | 'name'
    | 'sha'
    | 'branch'
    | 'description'
    | 'url'
    | 'externalUrl'
    | 'state'
    | 'phase'
    | 'externalKey'
    | 'goalSet'
    | 'registration'
    | 'goalSetId'
    | 'ts'
    | 'error'
    | 'retryFeasible'
    | 'approvalRequired'
    | 'preApprovalRequired'
    | 'parameters'
    | 'data'
    | 'version'
    | 'signature'
> & {
        fulfillment?: Maybe<
            {
                __typename?: 'SdmGoalFulfillment';
            } & Pick<SdmGoalFulfillment, 'method' | 'registration' | 'name'>
        >;
        externalUrls?: Maybe<
            Array<
                Maybe<
                    {
                        __typename?: 'SdmExternalUrl';
                    } & Pick<SdmExternalUrl, 'label' | 'url'>
                >
            >
        >;
        preConditions?: Maybe<
            Array<
                Maybe<
                    {
                        __typename?: 'SdmCondition';
                    } & Pick<SdmCondition, 'environment' | 'uniqueName' | 'name'>
                >
            >
        >;
        approval?: Maybe<
            {
                __typename?: 'SdmProvenance';
            } & Pick<
                SdmProvenance,
                | 'correlationId'
                | 'registration'
                | 'name'
                | 'version'
                | 'ts'
                | 'userId'
                | 'channelId'
            >
        >;
        preApproval?: Maybe<
            {
                __typename?: 'SdmProvenance';
            } & Pick<
                SdmProvenance,
                | 'correlationId'
                | 'registration'
                | 'name'
                | 'version'
                | 'ts'
                | 'userId'
                | 'channelId'
            >
        >;
        provenance?: Maybe<
            Array<
                Maybe<
                    {
                        __typename?: 'SdmProvenance';
                    } & Pick<
                        SdmProvenance,
                        | 'correlationId'
                        | 'registration'
                        | 'name'
                        | 'version'
                        | 'ts'
                        | 'userId'
                        | 'channelId'
                    >
                >
            >
        >;
        descriptions?: Maybe<
            {
                __typename?: 'SdmGoalDescriptions';
            } & Pick<
                SdmGoalDescriptions,
                | 'canceled'
                | 'completed'
                | 'failed'
                | 'inProcess'
                | 'planned'
                | 'requested'
                | 'stopped'
                | 'skipped'
                | 'waitingForApproval'
                | 'waitingForPreApproval'
            >
        >;
        push?: Maybe<
            ({
                __typename?: 'Push';
            } & {
                goals?: Maybe<
                    Array<
                        Maybe<
                            ({
                                __typename?: 'SdmGoal';
                            } & Pick<
                                SdmGoal,
                                | 'environment'
                                | 'uniqueName'
                                | 'name'
                                | 'sha'
                                | 'branch'
                                | 'description'
                                | 'url'
                                | 'externalUrl'
                                | 'state'
                                | 'phase'
                                | 'externalKey'
                                | 'goalSet'
                                | 'registration'
                                | 'goalSetId'
                                | 'ts'
                                | 'error'
                                | 'retryFeasible'
                                | 'approvalRequired'
                                | 'preApprovalRequired'
                                | 'parameters'
                                | 'data'
                                | 'version'
                            > & {
                                    fulfillment?: Maybe<
                                        {
                                            __typename?: 'SdmGoalFulfillment';
                                        } & Pick<
                                            SdmGoalFulfillment,
                                            'method' | 'registration' | 'name'
                                        >
                                    >;
                                    externalUrls?: Maybe<
                                        Array<
                                            Maybe<
                                                {
                                                    __typename?: 'SdmExternalUrl';
                                                } & Pick<
                                                    SdmExternalUrl,
                                                    'label' | 'url'
                                                >
                                            >
                                        >
                                    >;
                                    preConditions?: Maybe<
                                        Array<
                                            Maybe<
                                                {
                                                    __typename?: 'SdmCondition';
                                                } & Pick<
                                                    SdmCondition,
                                                    | 'environment'
                                                    | 'uniqueName'
                                                    | 'name'
                                                >
                                            >
                                        >
                                    >;
                                    approval?: Maybe<
                                        {
                                            __typename?: 'SdmProvenance';
                                        } & Pick<
                                            SdmProvenance,
                                            | 'correlationId'
                                            | 'registration'
                                            | 'name'
                                            | 'version'
                                            | 'ts'
                                            | 'userId'
                                            | 'channelId'
                                        >
                                    >;
                                    preApproval?: Maybe<
                                        {
                                            __typename?: 'SdmProvenance';
                                        } & Pick<
                                            SdmProvenance,
                                            | 'correlationId'
                                            | 'registration'
                                            | 'name'
                                            | 'version'
                                            | 'ts'
                                            | 'userId'
                                            | 'channelId'
                                        >
                                    >;
                                    provenance?: Maybe<
                                        Array<
                                            Maybe<
                                                {
                                                    __typename?: 'SdmProvenance';
                                                } & Pick<
                                                    SdmProvenance,
                                                    | 'correlationId'
                                                    | 'registration'
                                                    | 'name'
                                                    | 'version'
                                                    | 'ts'
                                                    | 'userId'
                                                    | 'channelId'
                                                >
                                            >
                                        >
                                    >;
                                    descriptions?: Maybe<
                                        {
                                            __typename?: 'SdmGoalDescriptions';
                                        } & Pick<
                                            SdmGoalDescriptions,
                                            | 'canceled'
                                            | 'completed'
                                            | 'failed'
                                            | 'inProcess'
                                            | 'planned'
                                            | 'requested'
                                            | 'stopped'
                                            | 'skipped'
                                            | 'waitingForApproval'
                                            | 'waitingForPreApproval'
                                        >
                                    >;
                                }) &
                                SdmGoalRepoFragment
                        >
                    >
                >;
            }) &
                PushFieldsFragment
        >;
    };

type SdmListener

type SdmListener<I extends ListenerInvocation, R extends any = any> = Function1<
    I,
    Promise<R>
>;

Mapper from a ListenerInvocation to any result

type SdmPreference

type SdmPreference = {
    __typename?: 'SdmPreference';
    key?: Maybe<Scalars['String']>;
    ttl?: Maybe<Scalars['Int']>;
    value?: Maybe<Scalars['String']>;
    /** The ID of this SdmPreference */
    id?: Maybe<Scalars['ID']>;
};

type SdmPreferenceByKeyQuery

type SdmPreferenceByKeyQuery = {
    __typename?: 'Query';
} & {
    SdmPreference?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SdmPreference';
                } & Pick<SdmPreference, 'key' | 'value' | 'ttl'>
            >
        >
    >;
};

type SdmPreferenceByKeyQueryVariables

type SdmPreferenceByKeyQueryVariables = {
    key?: Maybe<Array<Scalars['String']>>;
};

type SdmProvenance

type SdmProvenance = {
    __typename?: 'SdmProvenance';
    channelId?: Maybe<Scalars['String']>;
    correlationId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    registration?: Maybe<Scalars['String']>;
    ts?: Maybe<Scalars['Int']>;
    userId?: Maybe<Scalars['String']>;
    version?: Maybe<Scalars['String']>;
};

type SdmRepoProvenance

type SdmRepoProvenance = {
    __typename?: 'SdmRepoProvenance';
    provenance?: Maybe<SdmProvenance>;
    repo?: Maybe<SdmRepository>;
    /** The ID of this SdmRepoProvenance */
    id?: Maybe<Scalars['ID']>;
};

type SdmRepoProvenanceRepoArgs

type SdmRepoProvenanceRepoArgs = {
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    providerId?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SdmRepository

type SdmRepository = {
    __typename?: 'SdmRepository';
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
};

type SdmVersion

type SdmVersion = {
    __typename?: 'SdmVersion';
    branch?: Maybe<Scalars['String']>;
    repo?: Maybe<SdmVersionRepository>;
    sha?: Maybe<Scalars['String']>;
    version?: Maybe<Scalars['String']>;
    /** The ID of this SdmVersion */
    id?: Maybe<Scalars['ID']>;
};

type SdmVersionForCommitQuery

type SdmVersionForCommitQuery = {
    __typename?: 'Query';
} & {
    SdmVersion?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'SdmVersion';
                } & Pick<SdmVersion, 'version'> & {
                        repo?: Maybe<
                            {
                                __typename?: 'SdmVersionRepository';
                            } & Pick<
                                SdmVersionRepository,
                                'name' | 'owner' | 'providerId'
                            >
                        >;
                    }
            >
        >
    >;
};

type SdmVersionForCommitQueryVariables

type SdmVersionForCommitQueryVariables = {
    sha?: Maybe<Array<Scalars['String']>>;
    branch?: Maybe<Array<Scalars['String']>>;
    name?: Maybe<Array<Scalars['String']>>;
    owner?: Maybe<Array<Scalars['String']>>;
    providerId?: Maybe<Array<Scalars['String']>>;
};

type SdmVersionRepoArgs

type SdmVersionRepoArgs = {
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    providerId?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SdmVersionRepository

type SdmVersionRepository = {
    __typename?: 'SdmVersionRepository';
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
};

type SecretProvider

type SecretProvider = ResourceProvider & {
    __typename?: 'SecretProvider';
    name: Scalars['String'];
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    _id: Scalars['Int'];
    id: Scalars['ID'];
    team: Team;
    authProviderId?: Maybe<Scalars['String']>;
    state?: Maybe<ResourceProviderState>;
    credential?: Maybe<Credential>;
    webhooks?: Maybe<Array<Maybe<Webhook>>>;
    createdAt: Scalars['String'];
    updatedAt: Scalars['String'];
    createdBy?: Maybe<Person>;
    updatedBy?: Maybe<Person>;
    metadata?: Maybe<ResourceProviderMetadata>;
};

type SecretProviderInput

type SecretProviderInput = {
    name: Scalars['String'];
};

type SecretProviderWebhooksArgs

type SecretProviderWebhooksArgs = {
    id?: Maybe<Scalars['ID']>;
};

type SetJobTaskStateMutation

type SetJobTaskStateMutation = {
    __typename?: 'Mutation';
} & {
    setAtmJobTaskState?: Maybe<
        {
            __typename?: 'AtmJobTask';
        } & Pick<AtmJobTask, 'id'>
    >;
};

type SetJobTaskStateMutationVariables

type SetJobTaskStateMutationVariables = {
    id: Scalars['ID'];
    state: AtmJobTaskStateInput;
};

type SetResourceProviderStateMutation

type SetResourceProviderStateMutation = {
    __typename?: 'Mutation';
} & {
    setResourceProviderState:
        | ({
              __typename?: 'SCMProvider';
          } & Pick<ScmProvider, 'id'>)
        | ({
              __typename?: 'GitHubAppResourceProvider';
          } & Pick<GitHubAppResourceProvider, 'id'>)
        | ({
              __typename?: 'DockerRegistryProvider';
          } & Pick<DockerRegistryProvider, 'id'>)
        | ({
              __typename?: 'DockerHubRegistryProvider';
          } & Pick<DockerHubRegistryProvider, 'id'>)
        | ({
              __typename?: 'GoogleContainerRegistryProvider';
          } & Pick<GoogleContainerRegistryProvider, 'id'>)
        | ({
              __typename?: 'JFrogDockerRegistryProvider';
          } & Pick<JFrogDockerRegistryProvider, 'id'>)
        | ({
              __typename?: 'GoogleCloudPlatformProvider';
          } & Pick<GoogleCloudPlatformProvider, 'id'>)
        | ({
              __typename?: 'KubernetesClusterProvider';
          } & Pick<KubernetesClusterProvider, 'id'>)
        | ({
              __typename?: 'ArtifactoryMavenRepositoryProvider';
          } & Pick<ArtifactoryMavenRepositoryProvider, 'id'>)
        | ({
              __typename?: 'NpmJSRegistryProvider';
          } & Pick<NpmJsRegistryProvider, 'id'>)
        | ({
              __typename?: 'GitHubNpmRegistryProvider';
          } & Pick<GitHubNpmRegistryProvider, 'id'>)
        | ({
              __typename?: 'GenericResourceProvider';
          } & Pick<GenericResourceProvider, 'id'>)
        | ({
              __typename?: 'BinaryRepositoryProvider';
          } & Pick<BinaryRepositoryProvider, 'id'>)
        | ({
              __typename?: 'SecretProvider';
          } & Pick<SecretProvider, 'id'>);
};

type SetResourceProviderStateMutationVariables

type SetResourceProviderStateMutationVariables = {
    id: Scalars['ID'];
    state: ResourceProviderStateName;
    error: Scalars['String'];
};

type SetTeamConfigurationMutation

type SetTeamConfigurationMutation = {
    __typename?: 'Mutation';
} & {
    setTeamConfiguration: {
        __typename?: 'TeamConfiguration';
    } & Pick<TeamConfiguration, 'name' | 'namespace'>;
};

type SetTeamConfigurationMutationVariables

type SetTeamConfigurationMutationVariables = {
    namespace: Scalars['String'];
    name: Scalars['String'];
    value: Scalars['String'];
    ttl?: Maybe<Scalars['Int']>;
};

type SlackChannel

type SlackChannel = {
    __typename?: 'SlackChannel';
    /** The id of the chat team */
    chatTeamId?: Maybe<Scalars['String']>;
    /** The name of the channel */
    name?: Maybe<Scalars['String']>;
    /** The id of the channel */
    id?: Maybe<Scalars['String']>;
};

A slack channel

type SourceFingerprint

type SourceFingerprint = {
    data?: Maybe<Scalars['String']>;
    displayName?: Maybe<Scalars['String']>;
    displayType?: Maybe<Scalars['String']>;
    displayValue?: Maybe<Scalars['String']>;
    id: Scalars['ID'];
    name: Scalars['String'];
    sha: Scalars['String'];
    type: Scalars['String'];
};

Fingerprint of some artifact in an SCM repository

type SourceFingerprintStats

type SourceFingerprintStats = {
    __typename?: 'SourceFingerprintStats';
    fingerprint: SourceFingerprint;
    /** How many repos has this fingerprint been seen in? */
    inRepos: Scalars['Int'];
};

type SpawnLogResult

type SpawnLogResult = HandlerResult & SpawnPromiseReturns;

Result returned by spawnAndLog after running a child process. It is compatible with handler results. To support both HandlerResult and SpawnPromiseReturns, the value of code and status are identical.

type Stage

type Stage = {
    __typename?: 'Stage';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** The name of this stage */
    name?: Maybe<Scalars['String']>;
    /** The pipeline that this stage belongs to */
    pipeline?: Maybe<Pipeline>;
    /** The list of jobs associated with this stage */
    jobs?: Maybe<Array<Maybe<Job>>>;
};

Stage-Node

type StartingPoint

type StartingPoint<PARAMS> =
    | Project
    | RemoteRepoRef
    | ((
          pi: PARAMS & CommandListenerInvocation<PARAMS>
      ) => RemoteRepoRef | Project | Promise<Project>);

Starting point before transformation. Normally the coordinates of a seed project, but can also be an in memory project or a function that computes a RemoteRepoRef or Project from the parameters.

type StartupListener

type StartupListener = Function1<AdminCommunicationContext, Promise<void>>;

Listener invoked on SDM startup

type StartupListenerInvocation

type StartupListenerInvocation = AdminCommunicationContext;

Invocation on SDM startup

type Status

type Status = {
    __typename?: 'Status';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** id of  Status */
    id?: Maybe<Scalars['ID']>;
    /** state of  Status */
    state?: Maybe<StatusState>;
    /** description of  Status */
    description?: Maybe<Scalars['String']>;
    /** targetUrl of  Status */
    targetUrl?: Maybe<Scalars['String']>;
    /** context of  Status */
    context?: Maybe<Scalars['String']>;
    /** timestamp of  Status */
    timestamp?: Maybe<Scalars['String']>;
    /** Status commit Commit */
    commit?: Maybe<Commit>;
};

Status-Node

type StatusCommitArgs

type StatusCommitArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

Status-Node

type Subscription

type Subscription = {
    __typename?: 'Subscription';
    /** Subscribe to OnSchedule cron events */
    OnSchedule: Array<OnSchedule>;
    Issue?: Maybe<Array<Maybe<Issue>>>;
    Comment?: Maybe<Array<Maybe<Comment>>>;
    Label?: Maybe<Array<Maybe<Label>>>;
    Repo?: Maybe<Array<Maybe<Repo>>>;
    Commit?: Maybe<Array<Maybe<Commit>>>;
    Push?: Maybe<Array<Maybe<Push>>>;
    Build?: Maybe<Array<Maybe<Build>>>;
    Pipeline?: Maybe<Array<Maybe<Pipeline>>>;
    Stage?: Maybe<Array<Maybe<Stage>>>;
    Job?: Maybe<Array<Maybe<Job>>>;
    Workflow?: Maybe<Array<Maybe<Workflow>>>;
    Branch?: Maybe<Array<Maybe<Branch>>>;
    DeletedBranch?: Maybe<Array<Maybe<DeletedBranch>>>;
    ChatId?: Maybe<Array<Maybe<ChatId>>>;
    ChatChannel?: Maybe<Array<Maybe<ChatChannel>>>;
    PullRequest?: Maybe<Array<Maybe<PullRequest>>>;
    Org?: Maybe<Array<Maybe<Org>>>;
    GitHubAppInstallation?: Maybe<Array<Maybe<GitHubAppInstallation>>>;
    SCMId?: Maybe<Array<Maybe<ScmId>>>;
    GitHubAppResourceUser?: Maybe<Array<Maybe<GitHubAppResourceUser>>>;
    GitHubId?: Maybe<Array<Maybe<GitHubId>>>;
    Tag?: Maybe<Array<Maybe<Tag>>>;
    K8Pod?: Maybe<Array<Maybe<K8Pod>>>;
    K8Container?: Maybe<Array<Maybe<K8Container>>>;
    DockerImage?: Maybe<Array<Maybe<DockerImage>>>;
    ImageLinked?: Maybe<Array<Maybe<ImageLinked>>>;
    Release?: Maybe<Array<Maybe<Release>>>;
    HerokuApp?: Maybe<Array<Maybe<HerokuApp>>>;
    Application?: Maybe<Array<Maybe<Application>>>;
    Team?: Maybe<Array<Maybe<Team>>>;
    ChatTeam?: Maybe<Array<Maybe<ChatTeam>>>;
    Person?: Maybe<Array<Maybe<Person>>>;
    Status?: Maybe<Array<Maybe<Status>>>;
    CheckSuite?: Maybe<Array<Maybe<CheckSuite>>>;
    CheckRun?: Maybe<Array<Maybe<CheckRun>>>;
    Email?: Maybe<Array<Maybe<Email>>>;
    PushImpact?: Maybe<Array<Maybe<DeprecatedPushImpact>>>;
    PullRequestImpact?: Maybe<Array<Maybe<PullRequestImpact>>>;
    GitHubProvider?: Maybe<Array<Maybe<GitHubProvider>>>;
    SCMProvider?: Maybe<Array<Maybe<ScmProvider>>>;
    GitHubAppResourceProvider?: Maybe<Array<Maybe<GitHubAppResourceProvider>>>;
    UserJoinedChannel?: Maybe<Array<Maybe<UserJoinedChannel>>>;
    Webhook?: Maybe<Array<Maybe<Webhook>>>;
    ChannelLink?: Maybe<Array<Maybe<ChannelLink>>>;
    Review?: Maybe<Array<Maybe<Review>>>;
    DockerRegistryProvider?: Maybe<Array<Maybe<DockerRegistryProvider>>>;
    DockerHubRegistryProvider: Array<DockerHubRegistryProvider>;
    GoogleContainerRegistryProvider: Array<GoogleContainerRegistryProvider>;
    JFrogDockerRegistryProvider: Array<JFrogDockerRegistryProvider>;
    DockerRegistry: Array<DockerRegistry>;
    DockerRegistryImage: Array<DockerRegistryImage>;
    GoogleCloudPlatformProvider: Array<GoogleCloudPlatformProvider>;
    KubernetesClusterProvider: Array<KubernetesClusterProvider>;
    ArtifactoryMavenRepositoryProvider: Array<ArtifactoryMavenRepositoryProvider>;
    MavenRepositoryProvider: Array<MavenRepositoryProvider>;
    NpmJSRegistryProvider: Array<NpmJsRegistryProvider>;
    NpmRegistryProvider: Array<NpmRegistryProvider>;
    GitHubNpmRegistryProvider: Array<GitHubNpmRegistryProvider>;
    ResourceProvider?: Maybe<Array<Maybe<ResourceProvider>>>;
    Resource: Array<Resource>;
    GenericResourceUser?: Maybe<Array<Maybe<GenericResourceUser>>>;
    ResourceUser?: Maybe<Array<Maybe<ResourceUser>>>;
    SystemAccount?: Maybe<Array<Maybe<SystemAccount>>>;
    Credential?: Maybe<Array<Maybe<Credential>>>;
    OAuthToken?: Maybe<Array<Maybe<OAuthToken>>>;
    Password?: Maybe<Array<Maybe<Password>>>;
    GenericResourceProvider?: Maybe<Array<Maybe<GenericResourceProvider>>>;
    BinaryRepositoryProvider?: Maybe<Array<Maybe<BinaryRepositoryProvider>>>;
    SecretProvider: Array<SecretProvider>;
    CommitFingerprintImpact: Array<Maybe<CommitFingerprintImpact>>;
    /** Return AtmJobs */
    AtmJob?: Maybe<Array<AtmJob>>;
    /** Return AtmJobTasks */
    AtmJobTask?: Maybe<Array<AtmJobTask>>;
    AtomistLog: Array<AtomistLog>;
    /** Auto-generated subscription for Card */
    Card?: Maybe<Array<Maybe<Card>>>;
    /** Auto-generated subscription for Notification */
    Notification?: Maybe<Array<Maybe<Notification>>>;
    /** Auto-generated subscription for CommitIssueRelationship */
    CommitIssueRelationship?: Maybe<Array<Maybe<CommitIssueRelationship>>>;
    /** Auto-generated subscription for Deployment */
    Deployment?: Maybe<Array<Maybe<Deployment>>>;
    /** Auto-generated subscription for IssueRelationship */
    IssueRelationship?: Maybe<Array<Maybe<IssueRelationship>>>;
    /** Auto-generated subscription for SdmGoal */
    SdmGoal?: Maybe<Array<Maybe<SdmGoal>>>;
    /** Auto-generated subscription for SdmGoalSet */
    SdmGoalSet?: Maybe<Array<Maybe<SdmGoalSet>>>;
    /** Auto-generated subscription for SdmGoalDisplay */
    SdmGoalDisplay?: Maybe<Array<Maybe<SdmGoalDisplay>>>;
    /** Auto-generated subscription for SdmBuildIdentifier */
    SdmBuildIdentifier?: Maybe<Array<Maybe<SdmBuildIdentifier>>>;
    /** Auto-generated subscription for SdmDeployEnablement */
    SdmDeployEnablement?: Maybe<Array<Maybe<SdmDeployEnablement>>>;
    /** Auto-generated subscription for SdmVersion */
    SdmVersion?: Maybe<Array<Maybe<SdmVersion>>>;
    /** Auto-generated subscription for SdmGoalSetBadge */
    SdmGoalSetBadge?: Maybe<Array<Maybe<SdmGoalSetBadge>>>;
    /** Auto-generated subscription for SdmPreference */
    SdmPreference?: Maybe<Array<Maybe<SdmPreference>>>;
    /** Auto-generated subscription for SdmRepoProvenance */
    SdmRepoProvenance?: Maybe<Array<Maybe<SdmRepoProvenance>>>;
    /** Auto-generated subscription for PolicyLog */
    PolicyLog?: Maybe<Array<Maybe<PolicyLog>>>;
    /** Auto-generated subscription for PolicyCompliance */
    PolicyCompliance?: Maybe<Array<Maybe<PolicyCompliance>>>;
    /** Auto-generated subscription for PolicyTargetStream */
    PolicyTargetStream?: Maybe<Array<Maybe<PolicyTargetStream>>>;
    /** Auto-generated subscription for PolicyTarget */
    PolicyTarget?: Maybe<Array<Maybe<PolicyTarget>>>;
    /** Auto-generated subscription for LifecycleAttachment */
    LifecycleAttachment?: Maybe<Array<Maybe<LifecycleAttachment>>>;
    /** Auto-generated subscription for AspectRegistration */
    AspectRegistration?: Maybe<Array<Maybe<AspectRegistration>>>;
    RepoOnboarded?: Maybe<Array<Maybe<RepoOnboarded>>>;
};

type SubscriptionApplicationArgs

type SubscriptionApplicationArgs = {
    id?: Maybe<Scalars['ID']>;
    state?: Maybe<Scalars['String']>;
    host?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    domain?: Maybe<Scalars['String']>;
    data?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    states?: Maybe<Array<Maybe<Scalars['String']>>>;
    hosts?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    domains?: Maybe<Array<Maybe<Scalars['String']>>>;
    datas?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_ApplicationOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionArtifactoryMavenRepositoryProviderArgs

type SubscriptionArtifactoryMavenRepositoryProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionAspectRegistrationArgs

type SubscriptionAspectRegistrationArgs = {
    category?: Maybe<Array<Maybe<Scalars['String']>>>;
    description?: Maybe<Array<Maybe<Scalars['String']>>>;
    displayName?: Maybe<Array<Maybe<Scalars['String']>>>;
    endpoint?: Maybe<Array<Maybe<Scalars['String']>>>;
    manageable?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    shortName?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<AspectRegistrationState>>>;
    unit?: Maybe<Array<Maybe<Scalars['String']>>>;
    url?: Maybe<Array<Maybe<Scalars['String']>>>;
    uuid?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SubscriptionAtmJobArgs

type SubscriptionAtmJobArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    state?: Maybe<AtmJobState>;
};

type SubscriptionAtmJobTaskArgs

type SubscriptionAtmJobTaskArgs = {
    id?: Maybe<Scalars['ID']>;
    jobId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    owner?: Maybe<Scalars['String']>;
    state?: Maybe<AtmJobTaskState>;
};

type SubscriptionAtomistLogArgs

type SubscriptionAtomistLogArgs = {
    _after?: Maybe<Scalars['String']>;
    _before?: Maybe<Scalars['String']>;
    _first?: Maybe<Scalars['Int']>;
    _offset?: Maybe<Scalars['Int']>;
    _orderBy?: Maybe<Scalars['String']>;
    _ordering?: Maybe<_AtomistLogOrdering>;
    _search?: Maybe<Scalars['String']>;
    category?: Maybe<Array<Scalars['String']>>;
    id?: Maybe<Scalars['ID']>;
    level?: Maybe<Array<Scalars['String']>>;
    message?: Maybe<Array<Scalars['String']>>;
    team_id?: Maybe<Array<Scalars['String']>>;
    timestamp?: Maybe<Array<Scalars['String']>>;
};

type SubscriptionBinaryRepositoryProviderArgs

type SubscriptionBinaryRepositoryProviderArgs = {
    id?: Maybe<Scalars['ID']>;
    url?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    type?: Maybe<BinaryRepositoryType>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionBranchArgs

type SubscriptionBranchArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    isRemote?: Maybe<Scalars['Boolean']>;
    remoteRepoHtmlUrl?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    remoteRepoHtmlUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_BranchOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionBuildArgs

type SubscriptionBuildArgs = {
    id?: Maybe<Scalars['ID']>;
    buildId?: Maybe<Scalars['String']>;
    number?: Maybe<Scalars['Int']>;
    name?: Maybe<Scalars['String']>;
    status?: Maybe<BuildStatus>;
    buildUrl?: Maybe<Scalars['String']>;
    compareUrl?: Maybe<Scalars['String']>;
    trigger?: Maybe<BuildTrigger>;
    provider?: Maybe<Scalars['String']>;
    pullRequestNumber?: Maybe<Scalars['Float']>;
    startedAt?: Maybe<Scalars['String']>;
    finishedAt?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    workflowId?: Maybe<Scalars['String']>;
    jobName?: Maybe<Scalars['String']>;
    jobId?: Maybe<Scalars['String']>;
    data?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    buildIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    numbers?: Maybe<Array<Maybe<Scalars['Int']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    statuss?: Maybe<Array<Maybe<BuildStatus>>>;
    buildUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    compareUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    triggers?: Maybe<Array<Maybe<BuildTrigger>>>;
    providers?: Maybe<Array<Maybe<Scalars['String']>>>;
    pullRequestNumbers?: Maybe<Array<Maybe<Scalars['Float']>>>;
    startedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    finishedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    workflowIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    jobNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    jobIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    datas?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_BuildOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionCardArgs

type SubscriptionCardArgs = {
    key?: Maybe<Array<Maybe<Scalars['String']>>>;
    post?: Maybe<Array<Maybe<Scalars['String']>>>;
    shortTitle?: Maybe<Array<Maybe<Scalars['String']>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
    ttl?: Maybe<Array<Maybe<Scalars['Int']>>>;
    type?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SubscriptionChannelLinkArgs

type SubscriptionChannelLinkArgs = {
    id?: Maybe<Scalars['ID']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    orderBy?: Maybe<Array<Maybe<_ChannelLinkOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionChatChannelArgs

type SubscriptionChatChannelArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    normalizedName?: Maybe<Scalars['String']>;
    channelId?: Maybe<Scalars['String']>;
    isDefault?: Maybe<Scalars['Boolean']>;
    botInvitedSelf?: Maybe<Scalars['Boolean']>;
    archived?: Maybe<Scalars['Boolean']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    providers?: Maybe<Array<Maybe<Scalars['String']>>>;
    normalizedNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    channelIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_ChatChannelOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_ChatChannelFilter>;
};

type SubscriptionChatIdArgs

type SubscriptionChatIdArgs = {
    id?: Maybe<Scalars['ID']>;
    screenName?: Maybe<Scalars['String']>;
    userId?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    isAtomistBot?: Maybe<Scalars['String']>;
    isOwner?: Maybe<Scalars['String']>;
    isPrimaryOwner?: Maybe<Scalars['String']>;
    isAdmin?: Maybe<Scalars['String']>;
    isBot?: Maybe<Scalars['String']>;
    timezoneLabel?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    screenNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    userIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    providers?: Maybe<Array<Maybe<Scalars['String']>>>;
    timezoneLabels?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_ChatIdOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionChatTeamArgs

type SubscriptionChatTeamArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    tenantId?: Maybe<Scalars['String']>;
    domain?: Maybe<Scalars['String']>;
    messageCount?: Maybe<Scalars['Float']>;
    emailDomain?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    providers?: Maybe<Array<Maybe<Scalars['String']>>>;
    domains?: Maybe<Array<Maybe<Scalars['String']>>>;
    messageCounts?: Maybe<Array<Maybe<Scalars['Float']>>>;
    emailDomains?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_ChatTeamOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionCheckRunArgs

type SubscriptionCheckRunArgs = {
    id?: Maybe<Scalars['ID']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    orderBy?: Maybe<Array<Maybe<_CheckRunOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_CheckRunFilter>;
};

type SubscriptionCheckSuiteArgs

type SubscriptionCheckSuiteArgs = {
    id?: Maybe<Scalars['ID']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    orderBy?: Maybe<Array<Maybe<_CheckSuiteOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_CheckSuiteFilter>;
};

type SubscriptionCommentArgs

type SubscriptionCommentArgs = {
    id?: Maybe<Scalars['ID']>;
    body?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    commentId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    path?: Maybe<Scalars['String']>;
    position?: Maybe<Scalars['String']>;
    htmlUrl?: Maybe<Scalars['String']>;
    commentType?: Maybe<CommentCommentType>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    bodys?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    createdAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    updatedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    commentIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    gitHubIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    paths?: Maybe<Array<Maybe<Scalars['String']>>>;
    positions?: Maybe<Array<Maybe<Scalars['String']>>>;
    htmlUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    commentTypes?: Maybe<Array<Maybe<CommentCommentType>>>;
    orderBy?: Maybe<Array<Maybe<_CommentOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionCommitArgs

type SubscriptionCommitArgs = {
    id?: Maybe<Scalars['ID']>;
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    shas?: Maybe<Array<Maybe<Scalars['String']>>>;
    messages?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_CommitOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_CommitFilter>;
};

type SubscriptionCommitFingerprintImpactArgs

type SubscriptionCommitFingerprintImpactArgs = {
    id?: Maybe<Scalars['ID']>;
    type?: Maybe<Scalars['String']>;
};

type SubscriptionCommitIssueRelationshipArgs

type SubscriptionCommitIssueRelationshipArgs = {
    type?: Maybe<Array<Maybe<CommitIssueRelationshipType>>>;
};

type SubscriptionCredentialArgs

type SubscriptionCredentialArgs = {
    id?: Maybe<Scalars['ID']>;
    _id?: Maybe<Scalars['Int']>;
};

type SubscriptionDeletedBranchArgs

type SubscriptionDeletedBranchArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_DeletedBranchOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionDeploymentArgs

type SubscriptionDeploymentArgs = {
    environment?: Maybe<Array<Maybe<Scalars['String']>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
};

type SubscriptionDockerHubRegistryProviderArgs

type SubscriptionDockerHubRegistryProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionDockerImageArgs

type SubscriptionDockerImageArgs = {
    image?: Maybe<Scalars['String']>;
    imageName?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    images?: Maybe<Array<Maybe<Scalars['String']>>>;
    imageNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_DockerImageOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionDockerRegistryArgs

type SubscriptionDockerRegistryArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionDockerRegistryImageArgs

type SubscriptionDockerRegistryImageArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_DockerRegistryImageFilter>;
};

type SubscriptionDockerRegistryProviderArgs

type SubscriptionDockerRegistryProviderArgs = {
    id?: Maybe<Scalars['ID']>;
    url?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    type?: Maybe<DockerRegistryType>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionEmailArgs

type SubscriptionEmailArgs = {
    address?: Maybe<Scalars['String']>;
    addresss?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_EmailOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionGenericResourceProviderArgs

type SubscriptionGenericResourceProviderArgs = {
    id?: Maybe<Scalars['ID']>;
    url?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    type?: Maybe<Scalars['String']>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionGenericResourceUserArgs

type SubscriptionGenericResourceUserArgs = {
    login?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['ID']>;
    _id?: Maybe<Scalars['Int']>;
};

type SubscriptionGitHubAppInstallationArgs

type SubscriptionGitHubAppInstallationArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    ownerType?: Maybe<OwnerType>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    owners?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_GitHubAppInstallationOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionGitHubAppResourceProviderArgs

type SubscriptionGitHubAppResourceProviderArgs = {
    id?: Maybe<Scalars['ID']>;
    providerId?: Maybe<Scalars['String']>;
    _id?: Maybe<Scalars['Int']>;
};

type SubscriptionGitHubAppResourceUserArgs

type SubscriptionGitHubAppResourceUserArgs = {
    id?: Maybe<Scalars['ID']>;
    login?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_GitHubAppResourceUserOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionGitHubIdArgs

type SubscriptionGitHubIdArgs = {
    id?: Maybe<Scalars['ID']>;
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    logins?: Maybe<Array<Maybe<Scalars['String']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_GitHubIdOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionGitHubNpmRegistryProviderArgs

type SubscriptionGitHubNpmRegistryProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionGitHubProviderArgs

type SubscriptionGitHubProviderArgs = {
    id?: Maybe<Scalars['ID']>;
    private?: Maybe<Scalars['Boolean']>;
    url?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
    apiUrl?: Maybe<Scalars['String']>;
    gitUrl?: Maybe<Scalars['String']>;
    providerType?: Maybe<ProviderType>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    urls?: Maybe<Array<Maybe<Scalars['String']>>>;
    providerIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    apiUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    gitUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    providerTypes?: Maybe<Array<Maybe<ProviderType>>>;
    orderBy?: Maybe<Array<Maybe<_GitHubProviderOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionGoogleCloudPlatformProviderArgs

type SubscriptionGoogleCloudPlatformProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionGoogleContainerRegistryProviderArgs

type SubscriptionGoogleContainerRegistryProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionHerokuAppArgs

type SubscriptionHerokuAppArgs = {
    app?: Maybe<Scalars['String']>;
    url?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    user?: Maybe<Scalars['String']>;
    appId?: Maybe<Scalars['String']>;
    release?: Maybe<Scalars['String']>;
    apps?: Maybe<Array<Maybe<Scalars['String']>>>;
    urls?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    users?: Maybe<Array<Maybe<Scalars['String']>>>;
    appIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    releases?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_HerokuAppOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionImageLinkedArgs

type SubscriptionImageLinkedArgs = {
    timestamp?: Maybe<Scalars['String']>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_ImageLinkedOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionIssueArgs

type SubscriptionIssueArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    name?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<IssueState>;
    timestamp?: Maybe<Scalars['String']>;
    action?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    closedAt?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    numbers?: Maybe<Array<Maybe<Scalars['Float']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    titles?: Maybe<Array<Maybe<Scalars['String']>>>;
    bodys?: Maybe<Array<Maybe<Scalars['String']>>>;
    states?: Maybe<Array<Maybe<IssueState>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    actions?: Maybe<Array<Maybe<Scalars['String']>>>;
    createdAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    updatedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    closedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_IssueOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_IssueFilter>;
};

type SubscriptionIssueRelationshipArgs

type SubscriptionIssueRelationshipArgs = {
    relationshipId?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<Scalars['String']>>>;
    type?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SubscriptionJFrogDockerRegistryProviderArgs

type SubscriptionJFrogDockerRegistryProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionJobArgs

type SubscriptionJobArgs = {
    _id?: Maybe<Scalars['Int']>;
    name?: Maybe<Scalars['String']>;
    jobId?: Maybe<Scalars['ID']>;
};

type SubscriptionK8ContainerArgs

type SubscriptionK8ContainerArgs = {
    name?: Maybe<Scalars['String']>;
    imageName?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    environment?: Maybe<Scalars['String']>;
    clusterName?: Maybe<Scalars['String']>;
    containerJSON?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    stateReason?: Maybe<Scalars['String']>;
    ready?: Maybe<Scalars['Boolean']>;
    restartCount?: Maybe<Scalars['Int']>;
    statusJSON?: Maybe<Scalars['String']>;
    resourceVersion?: Maybe<Scalars['Int']>;
    containerID?: Maybe<Scalars['String']>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    imageNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    environments?: Maybe<Array<Maybe<Scalars['String']>>>;
    containerJSONs?: Maybe<Array<Maybe<Scalars['String']>>>;
    states?: Maybe<Array<Maybe<Scalars['String']>>>;
    stateReasons?: Maybe<Array<Maybe<Scalars['String']>>>;
    restartCounts?: Maybe<Array<Maybe<Scalars['Int']>>>;
    statusJSONs?: Maybe<Array<Maybe<Scalars['String']>>>;
    resourceVersions?: Maybe<Array<Maybe<Scalars['Int']>>>;
    containerIDs?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_K8ContainerOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionK8PodArgs

type SubscriptionK8PodArgs = {
    name?: Maybe<Scalars['String']>;
    phase?: Maybe<Scalars['String']>;
    environment?: Maybe<Scalars['String']>;
    clusterName?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    baseName?: Maybe<Scalars['String']>;
    namespace?: Maybe<Scalars['String']>;
    statusJSON?: Maybe<Scalars['String']>;
    host?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    specsJSON?: Maybe<Scalars['String']>;
    envJSON?: Maybe<Scalars['String']>;
    metadataJSON?: Maybe<Scalars['String']>;
    containersCrashLoopBackOff?: Maybe<Scalars['Boolean']>;
    resourceVersion?: Maybe<Scalars['Int']>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    phases?: Maybe<Array<Maybe<Scalars['String']>>>;
    environments?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    baseNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    namespaces?: Maybe<Array<Maybe<Scalars['String']>>>;
    statusJSONs?: Maybe<Array<Maybe<Scalars['String']>>>;
    hosts?: Maybe<Array<Maybe<Scalars['String']>>>;
    states?: Maybe<Array<Maybe<Scalars['String']>>>;
    specsJSONs?: Maybe<Array<Maybe<Scalars['String']>>>;
    envJSONs?: Maybe<Array<Maybe<Scalars['String']>>>;
    metadataJSONs?: Maybe<Array<Maybe<Scalars['String']>>>;
    resourceVersions?: Maybe<Array<Maybe<Scalars['Int']>>>;
    orderBy?: Maybe<Array<Maybe<_K8PodOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_K8PodFilter>;
};

type SubscriptionKubernetesClusterProviderArgs

type SubscriptionKubernetesClusterProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionLabelArgs

type SubscriptionLabelArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    default?: Maybe<Scalars['String']>;
    color?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    defaults?: Maybe<Array<Maybe<Scalars['String']>>>;
    colors?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_LabelOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionLifecycleAttachmentArgs

type SubscriptionLifecycleAttachmentArgs = {
    body?: Maybe<Array<Maybe<Scalars['String']>>>;
    configuration?: Maybe<Array<Maybe<Scalars['String']>>>;
    contentType?: Maybe<Array<Maybe<Scalars['String']>>>;
    identifier?: Maybe<Array<Maybe<Scalars['String']>>>;
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    skill?: Maybe<Array<Maybe<Scalars['String']>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
    type?: Maybe<Array<Maybe<LifecycleAttachmentType>>>;
};

type SubscriptionMavenRepositoryProviderArgs

type SubscriptionMavenRepositoryProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionNotificationArgs

type SubscriptionNotificationArgs = {
    body?: Maybe<Scalars['String']>;
    contentType?: Maybe<Scalars['String']>;
    correlationId?: Maybe<Scalars['String']>;
    key?: Maybe<Scalars['String']>;
    post?: Maybe<Array<Maybe<Scalars['String']>>>;
    ts?: Maybe<Scalars['Int']>;
    ttl?: Maybe<Array<Maybe<Scalars['Int']>>>;
};

type SubscriptionNpmJsRegistryProviderArgs

type SubscriptionNpmJsRegistryProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionNpmRegistryProviderArgs

type SubscriptionNpmRegistryProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionOAuthTokenArgs

type SubscriptionOAuthTokenArgs = {
    id?: Maybe<Scalars['ID']>;
    _id?: Maybe<Scalars['Int']>;
};

type SubscriptionOrgArgs

type SubscriptionOrgArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    ownerType?: Maybe<OwnerType>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    owners?: Maybe<Array<Maybe<Scalars['String']>>>;
    ownerTypes?: Maybe<Array<Maybe<OwnerType>>>;
    orderBy?: Maybe<Array<Maybe<_OrgOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_OrgFilter>;
};

type SubscriptionPasswordArgs

type SubscriptionPasswordArgs = {
    id?: Maybe<Scalars['ID']>;
    _id?: Maybe<Scalars['Int']>;
};

type SubscriptionPersonArgs

type SubscriptionPersonArgs = {
    id?: Maybe<Scalars['ID']>;
    forename?: Maybe<Scalars['String']>;
    surname?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    forenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    surnames?: Maybe<Array<Maybe<Scalars['String']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_PersonOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionPipelineArgs

type SubscriptionPipelineArgs = {
    _id?: Maybe<Scalars['Int']>;
    pipelineId?: Maybe<Scalars['ID']>;
    provider?: Maybe<Scalars['String']>;
    Status?: Maybe<PipelineStatus>;
};

type SubscriptionPolicyComplianceArgs

type SubscriptionPolicyComplianceArgs = {
    _branch?: Maybe<Array<Maybe<Scalars['String']>>>;
    _owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    _repo?: Maybe<Array<Maybe<Scalars['String']>>>;
    _sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<PolicyCompliaceState>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
};

type SubscriptionPolicyLogArgs

type SubscriptionPolicyLogArgs = {
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
    type?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SubscriptionPolicyTargetArgs

type SubscriptionPolicyTargetArgs = {
    data?: Maybe<Array<Maybe<Scalars['String']>>>;
    displayName?: Maybe<Array<Maybe<Scalars['String']>>>;
    displayValue?: Maybe<Array<Maybe<Scalars['String']>>>;
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    streams?: Maybe<Array<Maybe<Scalars['ID']>>>;
    type?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SubscriptionPolicyTargetStreamArgs

type SubscriptionPolicyTargetStreamArgs = {
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SubscriptionPullRequestArgs

type SubscriptionPullRequestArgs = {
    id?: Maybe<Scalars['ID']>;
    number?: Maybe<Scalars['Float']>;
    prId?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<Scalars['String']>;
    merged?: Maybe<Scalars['Boolean']>;
    timestamp?: Maybe<Scalars['String']>;
    baseBranchName?: Maybe<Scalars['String']>;
    branchName?: Maybe<Scalars['String']>;
    title?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    updatedAt?: Maybe<Scalars['String']>;
    closedAt?: Maybe<Scalars['String']>;
    mergedAt?: Maybe<Scalars['String']>;
    mergeStatus?: Maybe<MergeStatus>;
    action?: Maybe<PullRequestAction>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    numbers?: Maybe<Array<Maybe<Scalars['Float']>>>;
    prIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    bodys?: Maybe<Array<Maybe<Scalars['String']>>>;
    states?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    baseBranchNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    branchNames?: Maybe<Array<Maybe<Scalars['String']>>>;
    titles?: Maybe<Array<Maybe<Scalars['String']>>>;
    createdAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    updatedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    closedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    mergedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    mergeStatuss?: Maybe<Array<Maybe<MergeStatus>>>;
    actions?: Maybe<Array<Maybe<PullRequestAction>>>;
    orderBy?: Maybe<Array<Maybe<_PullRequestOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_PullRequestFilter>;
};

type SubscriptionPullRequestImpactArgs

type SubscriptionPullRequestImpactArgs = {
    id?: Maybe<Scalars['ID']>;
    url?: Maybe<Scalars['String']>;
    data?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    urls?: Maybe<Array<Maybe<Scalars['String']>>>;
    datas?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_PullRequestImpactOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionPushArgs

type SubscriptionPushArgs = {
    id?: Maybe<Scalars['ID']>;
    timestamp?: Maybe<Scalars['String']>;
    branch?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    branchs?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_PushOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_PushFilter>;
};

type SubscriptionPushImpactArgs

type SubscriptionPushImpactArgs = {
    id?: Maybe<Scalars['ID']>;
    url?: Maybe<Scalars['String']>;
    data?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    urls?: Maybe<Array<Maybe<Scalars['String']>>>;
    datas?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_PushImpactOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionReleaseArgs

type SubscriptionReleaseArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_ReleaseOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionRepoArgs

type SubscriptionRepoArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    allowRebaseMerge?: Maybe<Scalars['Boolean']>;
    allowSquashMerge?: Maybe<Scalars['Boolean']>;
    allowMergeCommit?: Maybe<Scalars['Boolean']>;
    repoId?: Maybe<Scalars['String']>;
    gitHubId?: Maybe<Scalars['String']>;
    defaultBranch?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    owners?: Maybe<Array<Maybe<Scalars['String']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    repoIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    gitHubIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    defaultBranchs?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_RepoOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_RepoFilter>;
};

type SubscriptionResourceArgs

type SubscriptionResourceArgs = {
    id?: Maybe<Scalars['ID']>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionResourceProviderArgs

type SubscriptionResourceProviderArgs = {
    authProviderId?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['ID']>;
    orderBy?: Maybe<Array<Maybe<_ResourceProviderOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionResourceUserArgs

type SubscriptionResourceUserArgs = {
    login?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['ID']>;
    _id?: Maybe<Scalars['Int']>;
};

type SubscriptionReviewArgs

type SubscriptionReviewArgs = {
    id?: Maybe<Scalars['ID']>;
    gitHubId?: Maybe<Scalars['String']>;
    reviewId?: Maybe<Scalars['String']>;
    body?: Maybe<Scalars['String']>;
    state?: Maybe<ReviewState>;
    submittedAt?: Maybe<Scalars['String']>;
    htmlUrl?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    gitHubIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    reviewIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    bodys?: Maybe<Array<Maybe<Scalars['String']>>>;
    states?: Maybe<Array<Maybe<ReviewState>>>;
    submittedAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    htmlUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_ReviewOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionScmIdArgs

type SubscriptionScmIdArgs = {
    id?: Maybe<Scalars['ID']>;
    login?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    avatar?: Maybe<Scalars['String']>;
    logins?: Maybe<Array<Maybe<Scalars['String']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    avatars?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_ScmIdOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionScmProviderArgs

type SubscriptionScmProviderArgs = {
    authProviderId?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['ID']>;
    private?: Maybe<Scalars['Boolean']>;
    url?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
    apiUrl?: Maybe<Scalars['String']>;
    gitUrl?: Maybe<Scalars['String']>;
    providerType?: Maybe<ProviderType>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    urls?: Maybe<Array<Maybe<Scalars['String']>>>;
    providerIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    apiUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    gitUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    providerTypes?: Maybe<Array<Maybe<ProviderType>>>;
    orderBy?: Maybe<Array<Maybe<_ScmProviderOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionSdmBuildIdentifierArgs

type SubscriptionSdmBuildIdentifierArgs = {
    identifier?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SubscriptionSdmDeployEnablementArgs

type SubscriptionSdmDeployEnablementArgs = {
    owner?: Maybe<Array<Maybe<Scalars['String']>>>;
    providerId?: Maybe<Array<Maybe<Scalars['String']>>>;
    repo?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<SdmDeployState>>>;
};

type SubscriptionSdmGoalArgs

type SubscriptionSdmGoalArgs = {
    approvalRequired?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
    branch?: Maybe<Array<Maybe<Scalars['String']>>>;
    data?: Maybe<Array<Maybe<Scalars['String']>>>;
    description?: Maybe<Array<Maybe<Scalars['String']>>>;
    environment?: Maybe<Array<Maybe<Scalars['String']>>>;
    error?: Maybe<Array<Maybe<Scalars['String']>>>;
    externalKey?: Maybe<Array<Maybe<Scalars['String']>>>;
    externalUrl?: Maybe<Array<Maybe<Scalars['String']>>>;
    goalSet?: Maybe<Array<Maybe<Scalars['String']>>>;
    goalSetId?: Maybe<Array<Maybe<Scalars['String']>>>;
    name?: Maybe<Array<Maybe<Scalars['String']>>>;
    parameters?: Maybe<Array<Maybe<Scalars['String']>>>;
    phase?: Maybe<Array<Maybe<Scalars['String']>>>;
    preApprovalRequired?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
    registration?: Maybe<Array<Maybe<Scalars['String']>>>;
    retryFeasible?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
    sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    signature?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<SdmGoalState>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
    uniqueName?: Maybe<Array<Maybe<Scalars['String']>>>;
    url?: Maybe<Array<Maybe<Scalars['String']>>>;
    version?: Maybe<Array<Maybe<Scalars['Int']>>>;
};

type SubscriptionSdmGoalDisplayArgs

type SubscriptionSdmGoalDisplayArgs = {
    branch?: Maybe<Array<Maybe<Scalars['String']>>>;
    format?: Maybe<Array<Maybe<SdmGoalDisplayFormat>>>;
    sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<SdmGoalDisplayState>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
};

type SubscriptionSdmGoalSetArgs

type SubscriptionSdmGoalSetArgs = {
    branch?: Maybe<Array<Maybe<Scalars['String']>>>;
    goalSet?: Maybe<Array<Maybe<Scalars['String']>>>;
    goalSetId?: Maybe<Array<Maybe<Scalars['String']>>>;
    sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    state?: Maybe<Array<Maybe<SdmGoalState>>>;
    ts?: Maybe<Array<Maybe<Scalars['Int']>>>;
};

type SubscriptionSdmGoalSetBadgeArgs

type SubscriptionSdmGoalSetBadgeArgs = {
    sdm?: Maybe<Array<Maybe<Scalars['String']>>>;
    token?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SubscriptionSdmPreferenceArgs

type SubscriptionSdmPreferenceArgs = {
    key?: Maybe<Array<Maybe<Scalars['String']>>>;
    ttl?: Maybe<Array<Maybe<Scalars['Int']>>>;
    value?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SubscriptionSdmVersionArgs

type SubscriptionSdmVersionArgs = {
    branch?: Maybe<Array<Maybe<Scalars['String']>>>;
    sha?: Maybe<Array<Maybe<Scalars['String']>>>;
    version?: Maybe<Array<Maybe<Scalars['String']>>>;
};

type SubscriptionSecretProviderArgs

type SubscriptionSecretProviderArgs = {
    _id?: Maybe<Scalars['Int']>;
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionStageArgs

type SubscriptionStageArgs = {
    _id?: Maybe<Scalars['Int']>;
    name?: Maybe<Scalars['String']>;
};

type SubscriptionStatusArgs

type SubscriptionStatusArgs = {
    id?: Maybe<Scalars['ID']>;
    state?: Maybe<StatusState>;
    description?: Maybe<Scalars['String']>;
    targetUrl?: Maybe<Scalars['String']>;
    context?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    states?: Maybe<Array<Maybe<StatusState>>>;
    descriptions?: Maybe<Array<Maybe<Scalars['String']>>>;
    targetUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    contexts?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_StatusOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionSystemAccountArgs

type SubscriptionSystemAccountArgs = {
    id?: Maybe<Scalars['ID']>;
    _id?: Maybe<Scalars['Int']>;
};

type SubscriptionTagArgs

type SubscriptionTagArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    ref?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    descriptions?: Maybe<Array<Maybe<Scalars['String']>>>;
    refs?: Maybe<Array<Maybe<Scalars['String']>>>;
    timestamps?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_TagOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    filter?: Maybe<_TagFilter>;
};

type SubscriptionTeamArgs

type SubscriptionTeamArgs = {
    id?: Maybe<Scalars['String']>;
    name?: Maybe<Scalars['String']>;
    description?: Maybe<Scalars['String']>;
    iconUrl?: Maybe<Scalars['String']>;
    createdAt?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['String']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    descriptions?: Maybe<Array<Maybe<Scalars['String']>>>;
    iconUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
    createdAts?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_TeamOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionUserJoinedChannelArgs

type SubscriptionUserJoinedChannelArgs = {
    id?: Maybe<Scalars['ID']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    orderBy?: Maybe<Array<Maybe<_UserJoinedChannelOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SubscriptionWebhookArgs

type SubscriptionWebhookArgs = {
    id?: Maybe<Scalars['ID']>;
    resourceProviderId?: Maybe<Scalars['String']>;
};

type SubscriptionWorkflowArgs

type SubscriptionWorkflowArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    workflowId?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    config?: Maybe<Scalars['String']>;
    ids?: Maybe<Array<Maybe<Scalars['ID']>>>;
    names?: Maybe<Array<Maybe<Scalars['String']>>>;
    workflowIds?: Maybe<Array<Maybe<Scalars['String']>>>;
    providers?: Maybe<Array<Maybe<Scalars['String']>>>;
    configs?: Maybe<Array<Maybe<Scalars['String']>>>;
    orderBy?: Maybe<Array<Maybe<_WorkflowOrdering>>>;
    _id?: Maybe<Scalars['Int']>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
};

type SystemAccount

type SystemAccount = ResourceUser & {
    __typename?: 'SystemAccount';
    createdBy?: Maybe<Person>;
    _typenames?: Maybe<Array<Maybe<Scalars['String']>>>;
    id: Scalars['ID'];
    _id?: Maybe<Scalars['Int']>;
    credential?: Maybe<Credential>;
    provider: ResourceProvider;
    login: Scalars['String'];
};

type SystemAccountProviderArgs

type SystemAccountProviderArgs = {
    id?: Maybe<Scalars['ID']>;
};

type Tag

type Tag = {
    __typename?: 'Tag';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** the URL of the Tag */
    url?: Maybe<Scalars['String']>;
    /** id of  Tag */
    id?: Maybe<Scalars['ID']>;
    /** name of  Tag */
    name?: Maybe<Scalars['String']>;
    /** description of  Tag */
    description?: Maybe<Scalars['String']>;
    /** ref of  Tag */
    ref?: Maybe<Scalars['String']>;
    /** timestamp of  Tag */
    timestamp?: Maybe<Scalars['String']>;
    /** Tag release Release */
    release?: Maybe<Release>;
    /** Tag commit Commit */
    commit?: Maybe<Commit>;
    /** Tag containers DockerImage */
    containers?: Maybe<Array<Maybe<DockerImage>>>;
    /** Tag builds Build */
    builds?: Maybe<Array<Maybe<Build>>>;
};

Tag-Node

type TagBuildsArgs

type TagBuildsArgs = {
    id?: Maybe<Scalars['ID']>;
    buildId?: Maybe<Scalars['String']>;
    number?: Maybe<Scalars['Int']>;
    name?: Maybe<Scalars['String']>;
    status?: Maybe<BuildStatus>;
    buildUrl?: Maybe<Scalars['String']>;
    compareUrl?: Maybe<Scalars['String']>;
    trigger?: Maybe<BuildTrigger>;
    provider?: Maybe<Scalars['String']>;
    pullRequestNumber?: Maybe<Scalars['Float']>;
    startedAt?: Maybe<Scalars['String']>;
    finishedAt?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    workflowId?: Maybe<Scalars['String']>;
    jobName?: Maybe<Scalars['String']>;
    jobId?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_BuildOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    data?: Maybe<Scalars['String']>;
};

Tag-Node

type TagCommitArgs

type TagCommitArgs = {
    sha?: Maybe<Scalars['String']>;
    message?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

Tag-Node

type TagContainersArgs

type TagContainersArgs = {
    image?: Maybe<Scalars['String']>;
    imageName?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_DockerImageOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    timestamp?: Maybe<Scalars['String']>;
};

Tag-Node

type TagGoalSet

type TagGoalSet = (
    goals: SdmGoalMessage[],
    pli: PushListenerInvocation
) => Promise<GoalSetTag[] | undefined>;

Create Tags for the goal set containing the provided goals

type TagInput

type TagInput = {
    name: Scalars['String'];
    value: Scalars['String'];
};

type TagListener

type TagListener = SdmListener<TagListenerInvocation>;

type TagReleaseArgs

type TagReleaseArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
};

Tag-Node

type Team

type Team = {
    __typename?: 'Team';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** the URL of the Team */
    url?: Maybe<Scalars['String']>;
    /** id of  Team */
    id?: Maybe<Scalars['String']>;
    /** name of  Team */
    name?: Maybe<Scalars['String']>;
    /** description of  Team */
    description?: Maybe<Scalars['String']>;
    /** iconUrl of  Team */
    iconUrl?: Maybe<Scalars['String']>;
    /** createdAt of  Team */
    createdAt?: Maybe<Scalars['String']>;
    /** Team persons Person */
    persons?: Maybe<Array<Maybe<Person>>>;
    /** Team orgs Org */
    orgs?: Maybe<Array<Maybe<Org>>>;
    /** Team providers GitHubProvider */
    providers?: Maybe<Array<Maybe<GitHubProvider>>>;
    resourceProviders?: Maybe<Array<Maybe<ResourceProvider>>>;
    /** Team scmProviders SCMProvider */
    scmProviders?: Maybe<Array<Maybe<ScmProvider>>>;
    /** Team chatTeams ChatTeam */
    chatTeams?: Maybe<Array<Maybe<ChatTeam>>>;
    configuration?: Maybe<Array<Maybe<TeamConfiguration>>>;
};

Team-Node

type TeamChatTeamsArgs

type TeamChatTeamsArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    tenantId?: Maybe<Scalars['String']>;
    domain?: Maybe<Scalars['String']>;
    messageCount?: Maybe<Scalars['Float']>;
    orderBy?: Maybe<Array<Maybe<_ChatTeamOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    emailDomain?: Maybe<Scalars['String']>;
};

Team-Node

type TeamConfiguration

type TeamConfiguration = {
    __typename?: 'TeamConfiguration';
    namespace: Scalars['String'];
    name: Scalars['String'];
    value: Scalars['String'];
    ttlSecs?: Maybe<Scalars['Int']>;
    createdAt: Scalars['String'];
    team: Team;
};

type TeamConfigurationArgs

type TeamConfigurationArgs = {
    namespace?: Maybe<Scalars['String']>;
};

Team-Node

type TeamConfigurationByNamespaceQuery

type TeamConfigurationByNamespaceQuery = {
    __typename?: 'Query';
} & {
    TeamConfiguration?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'TeamConfiguration';
                } & Pick<
                    TeamConfiguration,
                    'name' | 'namespace' | 'value' | 'ttlSecs' | 'createdAt'
                >
            >
        >
    >;
};

type TeamConfigurationByNamespaceQueryVariables

type TeamConfigurationByNamespaceQueryVariables = {
    namespace: Scalars['String'];
};

type TeamOrgsArgs

type TeamOrgsArgs = {
    id?: Maybe<Scalars['ID']>;
    owner?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_OrgOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    ownerType?: Maybe<OwnerType>;
};

Team-Node

type TeamPersonsArgs

type TeamPersonsArgs = {
    id?: Maybe<Scalars['ID']>;
    forename?: Maybe<Scalars['String']>;
    surname?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_PersonOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    name?: Maybe<Scalars['String']>;
};

Team-Node

type TeamPreference

type TeamPreference = {
    __typename?: 'TeamPreference';
    /** The name of the preference */
    name?: Maybe<Scalars['String']>;
    /** The value of the preference */
    value?: Maybe<Scalars['String']>;
};

A team's preferences as key/value pairs

type TeamProvidersArgs

type TeamProvidersArgs = {
    id?: Maybe<Scalars['ID']>;
    url?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
    apiUrl?: Maybe<Scalars['String']>;
    gitUrl?: Maybe<Scalars['String']>;
    providerType?: Maybe<ProviderType>;
};

Team-Node

type TeamResourceProvidersArgs

type TeamResourceProvidersArgs = {
    id?: Maybe<Scalars['ID']>;
    providerId?: Maybe<Scalars['String']>;
};

Team-Node

type TeamScmProvidersArgs

type TeamScmProvidersArgs = {
    id?: Maybe<Scalars['ID']>;
    url?: Maybe<Scalars['String']>;
    providerId?: Maybe<Scalars['String']>;
    apiUrl?: Maybe<Scalars['String']>;
    gitUrl?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_ScmProviderOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    providerType?: Maybe<ProviderType>;
};

Team-Node

type TransformPresentation

type TransformPresentation<PARAMS> = (
    papi: PushAwareParametersInvocation<PARAMS>,
    p: Project
) => EditMode;

Signature to create an EditMode out of a PushAwareParametersInvocation and Project.

type TransformResult

type TransformResult = EditResult;

type TransformReturnable

type TransformReturnable = Project | TransformResult | void;

type TriggeredListener

type TriggeredListener = Function1<AdminCommunicationContext, Promise<void>>;

Listener invoked by a trigger

type TriggeredListenerInvocation

type TriggeredListenerInvocation = AdminCommunicationContext;

Invocation when trigger occurs

type UpdatedIssueListener

type UpdatedIssueListener = SdmListener<UpdatedIssueListenerInvocation>;

type UpdateSdmGoalMutation

type UpdateSdmGoalMutation = {
    __typename?: 'Mutation';
} & Pick<Mutation, 'ingestCustomSdmGoal'>;

type UpdateSdmGoalMutationVariables

type UpdateSdmGoalMutationVariables = {
    goal: CustomSdmGoalInput;
};

type UpdateSdmGoalSetMutation

type UpdateSdmGoalSetMutation = {
    __typename?: 'Mutation';
} & Pick<Mutation, 'ingestCustomSdmGoalSet'>;

type UpdateSdmGoalSetMutationVariables

type UpdateSdmGoalSetMutationVariables = {
    goalSet: CustomSdmGoalSetInput;
};

type UpdateSdmVersionMutation

type UpdateSdmVersionMutation = {
    __typename?: 'Mutation';
} & Pick<Mutation, 'ingestCustomSdmVersion'>;

type UpdateSdmVersionMutationVariables

type UpdateSdmVersionMutationVariables = {
    version: CustomSdmVersionInput;
};

type UserJoinedChannel

type UserJoinedChannel = {
    __typename?: 'UserJoinedChannel';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** id of  UserJoinedChannel */
    id?: Maybe<Scalars['ID']>;
    /** UserJoinedChannel user ChatId */
    user?: Maybe<ChatId>;
    /** UserJoinedChannel channel ChatChannel */
    channel?: Maybe<ChatChannel>;
};

UserJoinedChannel-Node

type UserJoinedChannelChannelArgs

type UserJoinedChannelChannelArgs = {
    id?: Maybe<Scalars['ID']>;
    name?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    normalizedName?: Maybe<Scalars['String']>;
    channelId?: Maybe<Scalars['String']>;
    isDefault?: Maybe<Scalars['Boolean']>;
    botInvitedSelf?: Maybe<Scalars['Boolean']>;
    archived?: Maybe<Scalars['Boolean']>;
};

UserJoinedChannel-Node

type UserJoinedChannelUserArgs

type UserJoinedChannelUserArgs = {
    id?: Maybe<Scalars['ID']>;
    screenName?: Maybe<Scalars['String']>;
    userId?: Maybe<Scalars['String']>;
    provider?: Maybe<Scalars['String']>;
    isAtomistBot?: Maybe<Scalars['String']>;
    isOwner?: Maybe<Scalars['String']>;
    isPrimaryOwner?: Maybe<Scalars['String']>;
    isAdmin?: Maybe<Scalars['String']>;
    isBot?: Maybe<Scalars['String']>;
    timezoneLabel?: Maybe<Scalars['String']>;
};

UserJoinedChannel-Node

type UserJoiningChannelListener

type UserJoiningChannelListener = SdmListener<UserJoiningChannelListenerInvocation>;

Respond to a user joining a channel

type UserPreference

type UserPreference = {
    __typename?: 'UserPreference';
    /** The name of the preference */
    name?: Maybe<Scalars['String']>;
    /** The value of the preference */
    value?: Maybe<Scalars['String']>;
};

A user's preferences as key/value pairs

type ValueDeclaration

type ValueDeclaration = BaseValue;

Define values to be injected from the SDM configuration

type ValueParameterObjectValue

type ValueParameterObjectValue = ValueDeclaration;

type Webhook

type Webhook = {
    __typename?: 'Webhook';
    /** just a name */
    name: Scalars['String'];
    /** id of  Webhook */
    id: Scalars['ID'];
    /** url of  Webhook */
    url: Scalars['String'];
    /** type of validation */
    authType: WebhookAuthType;
    provider: ResourceProvider;
    tags?: Maybe<Array<Maybe<AtomistKeyValuePair>>>;
    state: WebhookState;
};

Webhook-Node

type WebhookInput

type WebhookInput = {
    name: Scalars['String'];
    resourceProviderId: Scalars['String'];
    authType: WebhookAuthType;
    hmacSha1?: Maybe<HmacSha1AuthInput>;
    tags?: Maybe<Array<Maybe<TagInput>>>;
    state?: Maybe<WebhookState>;
};

type WebhookUpdateInput

type WebhookUpdateInput = {
    name?: Maybe<Scalars['String']>;
    authType?: Maybe<WebhookAuthType>;
    hmacSha1?: Maybe<HmacSha1AuthInput>;
    tags?: Maybe<Array<Maybe<TagInput>>>;
    state?: Maybe<WebhookState>;
};

type WhatIsRunningQuery

type WhatIsRunningQuery = {
    __typename?: 'Query';
} & {
    Application?: Maybe<
        Array<
            Maybe<
                {
                    __typename?: 'Application';
                } & Pick<Application, 'domain'> & {
                        commits?: Maybe<
                            Array<
                                Maybe<
                                    {
                                        __typename?: 'Commit';
                                    } & Pick<Commit, 'sha'> & {
                                            repo?: Maybe<
                                                {
                                                    __typename?: 'Repo';
                                                } & Pick<Repo, 'owner' | 'name'>
                                            >;
                                        }
                                >
                            >
                        >;
                    }
            >
        >
    >;
};

type WhatIsRunningQueryVariables

type WhatIsRunningQueryVariables = {
    domain?: Maybe<Scalars['String']>;
};

type WithLoadedLazyProject

type WithLoadedLazyProject<T = any> = (p: GitProject & LazyProject) => Promise<T>;

type WithLoadedProject

type WithLoadedProject<T = any> = (p: GitProject) => Promise<T>;

Operation on loaded project

type Workflow

type Workflow = {
    __typename?: 'Workflow';
    /** internal node id */
    _id?: Maybe<Scalars['Int']>;
    /** id of  Workflow */
    id?: Maybe<Scalars['ID']>;
    /** name of  Workflow */
    name?: Maybe<Scalars['String']>;
    /** workflowId of  Workflow */
    workflowId?: Maybe<Scalars['String']>;
    /** provider of  Workflow */
    provider?: Maybe<Scalars['String']>;
    /** config of  Workflow */
    config?: Maybe<Scalars['String']>;
    /** Workflow builds Build */
    builds?: Maybe<Array<Maybe<Build>>>;
};

Workflow-Node

type WorkflowBuildsArgs

type WorkflowBuildsArgs = {
    id?: Maybe<Scalars['ID']>;
    buildId?: Maybe<Scalars['String']>;
    number?: Maybe<Scalars['Int']>;
    name?: Maybe<Scalars['String']>;
    status?: Maybe<BuildStatus>;
    buildUrl?: Maybe<Scalars['String']>;
    compareUrl?: Maybe<Scalars['String']>;
    trigger?: Maybe<BuildTrigger>;
    provider?: Maybe<Scalars['String']>;
    pullRequestNumber?: Maybe<Scalars['Float']>;
    startedAt?: Maybe<Scalars['String']>;
    finishedAt?: Maybe<Scalars['String']>;
    timestamp?: Maybe<Scalars['String']>;
    workflowId?: Maybe<Scalars['String']>;
    jobName?: Maybe<Scalars['String']>;
    jobId?: Maybe<Scalars['String']>;
    orderBy?: Maybe<Array<Maybe<_BuildOrdering>>>;
    first?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    data?: Maybe<Scalars['String']>;
};

Workflow-Node

Namespaces

namespace AddJobTasks

namespace AddJobTasks {}

type AddAtmJobTasks

type AddAtmJobTasks = NonNullable<AddJobTasksMutation['addAtmJobTasks']>;

type Mutation

type Mutation = AddJobTasksMutation;

type Variables

type Variables = AddJobTasksMutationVariables;

namespace BinaryRepositoryProvider

namespace BinaryRepositoryProvider {}

type BinaryRepositoryProvider

type BinaryRepositoryProvider = NonNullable<
    NonNullable<BinaryRepositoryProviderQuery['BinaryRepositoryProvider']>[0]
>;

type Credential

type Credential = NonNullable<
    NonNullable<
        NonNullable<BinaryRepositoryProviderQuery['BinaryRepositoryProvider']>[0]
    >['credential']
>;

type Owner

type Owner = NonNullable<
    NonNullable<
        NonNullable<BinaryRepositoryProviderQuery['BinaryRepositoryProvider']>[0]
    >['credential']
>['owner'];

type Query

type Query = BinaryRepositoryProviderQuery;

type State

type State = NonNullable<
    NonNullable<
        NonNullable<BinaryRepositoryProviderQuery['BinaryRepositoryProvider']>[0]
    >['state']
>;

type Variables

type Variables = BinaryRepositoryProviderQueryVariables;

namespace BranchForName

namespace BranchForName {}

type Branch

type Branch = NonNullable<NonNullable<BranchForNameQuery['Branch']>[0]>;

type Query

type Query = BranchForNameQuery;

type Repo

type Repo = NonNullable<
    NonNullable<NonNullable<BranchForNameQuery['Branch']>[0]>['repo']
>;

type Variables

type Variables = BranchForNameQueryVariables;

namespace BuildUrlBySha

namespace BuildUrlBySha {}

type Builds

type Builds = NonNullable<
    NonNullable<
        NonNullable<NonNullable<BuildUrlByShaQuery['Commit']>[0]>['builds']
    >[0]
>;

type Commit

type Commit = NonNullable<NonNullable<BuildUrlByShaQuery['Commit']>[0]>;

type Query

type Query = BuildUrlByShaQuery;

type Variables

type Variables = BuildUrlByShaQueryVariables;

namespace CanceledSdmGoal

namespace CanceledSdmGoal {}

type Query

type Query = CanceledSdmGoalQuery;

type SdmGoal

type SdmGoal = NonNullable<NonNullable<CanceledSdmGoalQuery['SdmGoal']>[0]>;

type Variables

type Variables = CanceledSdmGoalQueryVariables;

namespace CommitForSdmGoal

namespace CommitForSdmGoal {}

type Commit

type Commit = NonNullable<NonNullable<CommitForSdmGoalQuery['Commit']>[0]>;

type Image

type Image = NonNullable<
    NonNullable<NonNullable<CommitForSdmGoalQuery['Commit']>[0]>['image']
>;

type Images

type Images = NonNullable<
    NonNullable<
        NonNullable<NonNullable<CommitForSdmGoalQuery['Commit']>[0]>['images']
    >[0]
>;

type Pushes

type Pushes = PushFieldsFragment;

type Query

type Query = CommitForSdmGoalQuery;

type Repo

type Repo = CoreRepoFieldsAndChannelsFragment;

type Statuses

type Statuses = NonNullable<
    NonNullable<
        NonNullable<NonNullable<CommitForSdmGoalQuery['Commit']>[0]>['statuses']
    >[0]
>;

type Variables

type Variables = CommitForSdmGoalQueryVariables;

namespace CoreCommitFields

namespace CoreCommitFields {}

type Committer

type Committer = NonNullable<CoreCommitFieldsFragment['committer']>;

type Fragment

type Fragment = CoreCommitFieldsFragment;

type Person

type Person = PersonFieldsFragment;

namespace CoreRepoFieldsAndChannels

namespace CoreRepoFieldsAndChannels {}

type Channels

type Channels = NonNullable<
    NonNullable<CoreRepoFieldsAndChannelsFragment['channels']>[0]
>;

type Fragment

type Fragment = CoreRepoFieldsAndChannelsFragment;

type Org

type Org = NonNullable<CoreRepoFieldsAndChannelsFragment['org']>;

type Provider

type Provider = NonNullable<
    NonNullable<CoreRepoFieldsAndChannelsFragment['org']>['provider']
>;

type Team

type Team = NonNullable<
    NonNullable<
        NonNullable<CoreRepoFieldsAndChannelsFragment['channels']>[0]
    >['team']
>;

namespace CreateJob

namespace CreateJob {}

type CreateAtmJob

type CreateAtmJob = NonNullable<CreateJobMutation['createAtmJob']>;

type Mutation

type Mutation = CreateJobMutation;

type Variables

type Variables = CreateJobMutationVariables;

namespace DeleteResourceProvider

namespace DeleteResourceProvider {}

type Mutation

type Mutation = DeleteResourceProviderMutation;

type Variables

type Variables = DeleteResourceProviderMutationVariables;

namespace DeleteTeamConfiguration

namespace DeleteTeamConfiguration {}

type DeleteTeamConfiguration

type DeleteTeamConfiguration = NonNullable<
    DeleteTeamConfigurationMutation['deleteTeamConfiguration']
>;

type Mutation

type Mutation = DeleteTeamConfigurationMutation;

type Variables

type Variables = DeleteTeamConfigurationMutationVariables;

namespace DockerRegistryProvider

namespace DockerRegistryProvider {}

type Credential

type Credential = NonNullable<
    NonNullable<
        NonNullable<DockerRegistryProviderQuery['DockerRegistryProvider']>[0]
    >['credential']
>;

type DockerRegistryProvider

type DockerRegistryProvider = NonNullable<
    NonNullable<DockerRegistryProviderQuery['DockerRegistryProvider']>[0]
>;

type Owner

type Owner = NonNullable<
    NonNullable<
        NonNullable<DockerRegistryProviderQuery['DockerRegistryProvider']>[0]
    >['credential']
>['owner'];

type Query

type Query = DockerRegistryProviderQuery;

type State

type State = NonNullable<
    NonNullable<
        NonNullable<DockerRegistryProviderQuery['DockerRegistryProvider']>[0]
    >['state']
>;

type Variables

type Variables = DockerRegistryProviderQueryVariables;

namespace DockerRegistryProviderAll

namespace DockerRegistryProviderAll {}

type Credential

type Credential = NonNullable<
    NonNullable<
        NonNullable<DockerRegistryProviderAllQuery['DockerRegistryProvider']>[0]
    >['credential']
>;

type DockerRegistryProvider

type DockerRegistryProvider = NonNullable<
    NonNullable<DockerRegistryProviderAllQuery['DockerRegistryProvider']>[0]
>;

type Query

type Query = DockerRegistryProviderAllQuery;

type Variables

type Variables = DockerRegistryProviderAllQueryVariables;

namespace GenericResourceProvider

namespace GenericResourceProvider {}

type Credential

type Credential = NonNullable<
    NonNullable<
        NonNullable<GenericResourceProviderQuery['GenericResourceProvider']>[0]
    >['credential']
>;

type GenericResourceProvider

type GenericResourceProvider = NonNullable<
    NonNullable<GenericResourceProviderQuery['GenericResourceProvider']>[0]
>;

type Query

type Query = GenericResourceProviderQuery;

type Variables

type Variables = GenericResourceProviderQueryVariables;

namespace GitHubAppInstallationByOwner

namespace GitHubAppInstallationByOwner {}

type GitHubAppInstallation

type GitHubAppInstallation = NonNullable<
    NonNullable<GitHubAppInstallationByOwnerQuery['GitHubAppInstallation']>[0]
>;

type Query

type Query = GitHubAppInstallationByOwnerQuery;

type Token

type Token = NonNullable<
    NonNullable<
        NonNullable<GitHubAppInstallationByOwnerQuery['GitHubAppInstallation']>[0]
    >['token']
>;

type Variables

type Variables = GitHubAppInstallationByOwnerQueryVariables;

namespace GitHubAppResourceProvider

namespace GitHubAppResourceProvider {}

type GitHubAppResourceProvider

type GitHubAppResourceProvider = NonNullable<
    NonNullable<GitHubAppResourceProviderQuery['GitHubAppResourceProvider']>[0]
>;

type Query

type Query = GitHubAppResourceProviderQuery;

type Variables

type Variables = GitHubAppResourceProviderQueryVariables;

namespace GitHubLogin

namespace GitHubLogin {}

type ChatTeams

type ChatTeams = NonNullable<
    NonNullable<
        NonNullable<NonNullable<GitHubLoginQuery['Team']>[0]>['chatTeams']
    >[0]
>;

type GitHubId

type GitHubId = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<
                        NonNullable<
                            NonNullable<GitHubLoginQuery['Team']>[0]
                        >['chatTeams']
                    >[0]
                >['members']
            >[0]
        >['person']
    >['gitHubId']
>;

type Members

type Members = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<NonNullable<GitHubLoginQuery['Team']>[0]>['chatTeams']
            >[0]
        >['members']
    >[0]
>;

type Orgs

type Orgs = NonNullable<
    NonNullable<NonNullable<NonNullable<GitHubLoginQuery['Team']>[0]>['orgs']>[0]
>;

type Person

type Person = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<
                        NonNullable<GitHubLoginQuery['Team']>[0]
                    >['chatTeams']
                >[0]
            >['members']
        >[0]
    >['person']
>;

type Provider

type Provider = NonNullable<
    NonNullable<
        NonNullable<NonNullable<NonNullable<GitHubLoginQuery['Team']>[0]>['orgs']>[0]
    >['provider']
>;

type Query

type Query = GitHubLoginQuery;

type Team

type Team = NonNullable<NonNullable<GitHubLoginQuery['Team']>[0]>;

type Variables

type Variables = GitHubLoginQueryVariables;

namespace InProcessSdmGoals

namespace InProcessSdmGoals {}

type Approval

type Approval = NonNullable<
    NonNullable<NonNullable<InProcessSdmGoalsQuery['SdmGoal']>[0]>['approval']
>;

type Descriptions

type Descriptions = NonNullable<
    NonNullable<NonNullable<InProcessSdmGoalsQuery['SdmGoal']>[0]>['descriptions']
>;

type ExternalUrls

type ExternalUrls = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<InProcessSdmGoalsQuery['SdmGoal']>[0]
        >['externalUrls']
    >[0]
>;

type Fulfillment

type Fulfillment = NonNullable<
    NonNullable<NonNullable<InProcessSdmGoalsQuery['SdmGoal']>[0]>['fulfillment']
>;

type PreApproval

type PreApproval = NonNullable<
    NonNullable<NonNullable<InProcessSdmGoalsQuery['SdmGoal']>[0]>['preApproval']
>;

type PreConditions

type PreConditions = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<InProcessSdmGoalsQuery['SdmGoal']>[0]
        >['preConditions']
    >[0]
>;

type Provenance

type Provenance = NonNullable<
    NonNullable<
        NonNullable<NonNullable<InProcessSdmGoalsQuery['SdmGoal']>[0]>['provenance']
    >[0]
>;

type Push

type Push = PushFieldsFragment;

type Query

type Query = InProcessSdmGoalsQuery;

type SdmGoal

type SdmGoal = SdmGoalRepoFragment;

type Variables

type Variables = InProcessSdmGoalsQueryVariables;

namespace InProcessSdmGoalSets

namespace InProcessSdmGoalSets {}

type Goals

type Goals = NonNullable<
    NonNullable<
        NonNullable<NonNullable<InProcessSdmGoalSetsQuery['SdmGoalSet']>[0]>['goals']
    >[0]
>;

type Provenance

type Provenance = NonNullable<
    NonNullable<
        NonNullable<InProcessSdmGoalSetsQuery['SdmGoalSet']>[0]
    >['provenance']
>;

type Query

type Query = InProcessSdmGoalSetsQuery;

type Repo

type Repo = NonNullable<
    NonNullable<NonNullable<InProcessSdmGoalSetsQuery['SdmGoalSet']>[0]>['repo']
>;

type SdmGoalSet

type SdmGoalSet = NonNullable<
    NonNullable<InProcessSdmGoalSetsQuery['SdmGoalSet']>[0]
>;

type Tags

type Tags = NonNullable<
    NonNullable<
        NonNullable<NonNullable<InProcessSdmGoalSetsQuery['SdmGoalSet']>[0]>['tags']
    >[0]
>;

type Variables

type Variables = InProcessSdmGoalSetsQueryVariables;

namespace KubernetesDeployRequestedSdmGoal

namespace KubernetesDeployRequestedSdmGoal {}

type After

type After = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<KubernetesDeployRequestedSdmGoalSubscription['SdmGoal']>[0]
        >['push']
    >['after']
>;

type Author

type Author = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<
                        KubernetesDeployRequestedSdmGoalSubscription['SdmGoal']
                    >[0]
                >['push']
            >['commits']
        >[0]
    >['author']
>;

type Before

type Before = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<KubernetesDeployRequestedSdmGoalSubscription['SdmGoal']>[0]
        >['push']
    >['before']
>;

type Commits

type Commits = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    KubernetesDeployRequestedSdmGoalSubscription['SdmGoal']
                >[0]
            >['push']
        >['commits']
    >[0]
>;

type Committer

type Committer = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    KubernetesDeployRequestedSdmGoalSubscription['SdmGoal']
                >[0]
            >['push']
        >['before']
    >['committer']
>;

type Descriptions

type Descriptions = NonNullable<
    NonNullable<
        NonNullable<KubernetesDeployRequestedSdmGoalSubscription['SdmGoal']>[0]
    >['descriptions']
>;

type Fulfillment

type Fulfillment = NonNullable<
    NonNullable<
        NonNullable<KubernetesDeployRequestedSdmGoalSubscription['SdmGoal']>[0]
    >['fulfillment']
>;

type Images

type Images = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<
                        KubernetesDeployRequestedSdmGoalSubscription['SdmGoal']
                    >[0]
                >['push']
            >['after']
        >['images']
    >[0]
>;

type Org

type Org = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    KubernetesDeployRequestedSdmGoalSubscription['SdmGoal']
                >[0]
            >['push']
        >['repo']
    >['org']
>;

type PreApproval

type PreApproval = NonNullable<
    NonNullable<
        NonNullable<KubernetesDeployRequestedSdmGoalSubscription['SdmGoal']>[0]
    >['preApproval']
>;

type PreConditions

type PreConditions = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<KubernetesDeployRequestedSdmGoalSubscription['SdmGoal']>[0]
        >['preConditions']
    >[0]
>;

type Provenance

type Provenance = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<KubernetesDeployRequestedSdmGoalSubscription['SdmGoal']>[0]
        >['provenance']
    >[0]
>;

type Provider

type Provider = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<
                        KubernetesDeployRequestedSdmGoalSubscription['SdmGoal']
                    >[0]
                >['push']
            >['repo']
        >['org']
    >['provider']
>;

type Push

type Push = NonNullable<
    NonNullable<
        NonNullable<KubernetesDeployRequestedSdmGoalSubscription['SdmGoal']>[0]
    >['push']
>;

type Repo

type Repo = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<KubernetesDeployRequestedSdmGoalSubscription['SdmGoal']>[0]
        >['push']
    >['repo']
>;

type SdmGoal

type SdmGoal = NonNullable<
    NonNullable<KubernetesDeployRequestedSdmGoalSubscription['SdmGoal']>[0]
>;

type Subscription

type Subscription = KubernetesDeployRequestedSdmGoalSubscription;

type Variables

type Variables = KubernetesDeployRequestedSdmGoalSubscriptionVariables;

namespace LastEndpoint

namespace LastEndpoint {}

type Branches

type Branches = NonNullable<
    NonNullable<
        NonNullable<NonNullable<LastEndpointQuery['Repo']>[0]>['branches']
    >[0]
>;

type Commit

type Commit = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<NonNullable<LastEndpointQuery['Repo']>[0]>['branches']
        >[0]
    >['commit']
>;

type Pushes

type Pushes = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<
                        NonNullable<LastEndpointQuery['Repo']>[0]
                    >['branches']
                >[0]
            >['commit']
        >['pushes']
    >[0]
>;

type Query

type Query = LastEndpointQuery;

type Repo

type Repo = NonNullable<NonNullable<LastEndpointQuery['Repo']>[0]>;

type Statuses

type Statuses = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<
                        NonNullable<LastEndpointQuery['Repo']>[0]
                    >['branches']
                >[0]
            >['commit']
        >['statuses']
    >[0]
>;

type Variables

type Variables = LastEndpointQueryVariables;

namespace OnAnyApprovedSdmGoal

namespace OnAnyApprovedSdmGoal {}

type SdmGoal

type SdmGoal = SdmGoalRepoFragment;

type Subscription

type Subscription = OnAnyApprovedSdmGoalSubscription;

type Variables

type Variables = OnAnyApprovedSdmGoalSubscriptionVariables;

namespace OnAnyCompletedSdmGoal

namespace OnAnyCompletedSdmGoal {}

type SdmGoal

type SdmGoal = SdmGoalRepoFragment;

type Subscription

type Subscription = OnAnyCompletedSdmGoalSubscription;

type Variables

type Variables = OnAnyCompletedSdmGoalSubscriptionVariables;

namespace OnAnyFailedSdmGoal

namespace OnAnyFailedSdmGoal {}

type SdmGoal

type SdmGoal = SdmGoalRepoFragment;

type Subscription

type Subscription = OnAnyFailedSdmGoalSubscription;

type Variables

type Variables = OnAnyFailedSdmGoalSubscriptionVariables;

namespace OnAnyJobTask

namespace OnAnyJobTask {}

type AtmJobTask

type AtmJobTask = NonNullable<
    NonNullable<OnAnyJobTaskSubscription['AtmJobTask']>[0]
>;

type Job

type Job = NonNullable<
    NonNullable<OnAnyJobTaskSubscription['AtmJobTask']>[0]
>['job'];

type Subscription

type Subscription = OnAnyJobTaskSubscription;

type Variables

type Variables = OnAnyJobTaskSubscriptionVariables;

namespace OnAnyRequestedSdmGoal

namespace OnAnyRequestedSdmGoal {}

type SdmGoal

type SdmGoal = SdmGoalRepoFragment;

type Subscription

type Subscription = OnAnyRequestedSdmGoalSubscription;

type Variables

type Variables = OnAnyRequestedSdmGoalSubscriptionVariables;

namespace OnAnySdmGoalSet

namespace OnAnySdmGoalSet {}

type Goals

type Goals = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<OnAnySdmGoalSetSubscription['SdmGoalSet']>[0]
        >['goals']
    >[0]
>;

type Provenance

type Provenance = NonNullable<
    NonNullable<
        NonNullable<OnAnySdmGoalSetSubscription['SdmGoalSet']>[0]
    >['provenance']
>;

type Repo

type Repo = NonNullable<
    NonNullable<NonNullable<OnAnySdmGoalSetSubscription['SdmGoalSet']>[0]>['repo']
>;

type SdmGoalSet

type SdmGoalSet = NonNullable<
    NonNullable<OnAnySdmGoalSetSubscription['SdmGoalSet']>[0]
>;

type Subscription

type Subscription = OnAnySdmGoalSetSubscription;

type Tags

type Tags = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<OnAnySdmGoalSetSubscription['SdmGoalSet']>[0]
        >['tags']
    >[0]
>;

type Variables

type Variables = OnAnySdmGoalSetSubscriptionVariables;

namespace OnAnySuccessfulSdmGoal

namespace OnAnySuccessfulSdmGoal {}

type SdmGoal

type SdmGoal = SdmGoalRepoFragment;

type Subscription

type Subscription = OnAnySuccessfulSdmGoalSubscription;

type Variables

type Variables = OnAnySuccessfulSdmGoalSubscriptionVariables;

namespace OnBuildComplete

namespace OnBuildComplete {}

type Build

type Build = NonNullable<NonNullable<OnBuildCompleteSubscription['Build']>[0]>;

type Commit

type Commit = NonNullable<
    NonNullable<NonNullable<OnBuildCompleteSubscription['Build']>[0]>['commit']
>;

type Push

type Push = PushFieldsFragment;

type Repo

type Repo = CoreRepoFieldsAndChannelsFragment;

type Statuses

type Statuses = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<OnBuildCompleteSubscription['Build']>[0]
            >['commit']
        >['statuses']
    >[0]
>;

type Subscription

type Subscription = OnBuildCompleteSubscription;

type Variables

type Variables = OnBuildCompleteSubscriptionVariables;

namespace OnBuildCompleteForDryRun

namespace OnBuildCompleteForDryRun {}

type Build

type Build = NonNullable<
    NonNullable<OnBuildCompleteForDryRunSubscription['Build']>[0]
>;

type Commit

type Commit = NonNullable<
    NonNullable<
        NonNullable<OnBuildCompleteForDryRunSubscription['Build']>[0]
    >['commit']
>;

type Pushes

type Pushes = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<OnBuildCompleteForDryRunSubscription['Build']>[0]
            >['commit']
        >['pushes']
    >[0]
>;

type Repo

type Repo = CoreRepoFieldsAndChannelsFragment;

type Statuses

type Statuses = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<OnBuildCompleteForDryRunSubscription['Build']>[0]
            >['commit']
        >['statuses']
    >[0]
>;

type Subscription

type Subscription = OnBuildCompleteForDryRunSubscription;

type Variables

type Variables = OnBuildCompleteForDryRunSubscriptionVariables;

namespace OnChannelLink

namespace OnChannelLink {}

type Channel

type Channel = NonNullable<
    NonNullable<NonNullable<OnChannelLinkSubscription['ChannelLink']>[0]>['channel']
>;

type ChannelLink

type ChannelLink = NonNullable<
    NonNullable<OnChannelLinkSubscription['ChannelLink']>[0]
>;

type Repo

type Repo = CoreRepoFieldsAndChannelsFragment;

type Subscription

type Subscription = OnChannelLinkSubscription;

type Team

type Team = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<OnChannelLinkSubscription['ChannelLink']>[0]
        >['channel']
    >['team']
>;

type Variables

type Variables = OnChannelLinkSubscriptionVariables;

namespace OnClosedIssue

namespace OnClosedIssue {}

type Assignees

type Assignees = NonNullable<
    NonNullable<
        NonNullable<NonNullable<OnClosedIssueSubscription['Issue']>[0]>['assignees']
    >[0]
>;

type ClosedBy

type ClosedBy = NonNullable<
    NonNullable<NonNullable<OnClosedIssueSubscription['Issue']>[0]>['closedBy']
>;

type Issue

type Issue = NonNullable<NonNullable<OnClosedIssueSubscription['Issue']>[0]>;

type OpenedBy

type OpenedBy = NonNullable<
    NonNullable<NonNullable<OnClosedIssueSubscription['Issue']>[0]>['openedBy']
>;

type Person

type Person = PersonFieldsFragment;

type Repo

type Repo = CoreRepoFieldsAndChannelsFragment;

type Subscription

type Subscription = OnClosedIssueSubscription;

type Variables

type Variables = OnClosedIssueSubscriptionVariables;

namespace OnFirstPushToRepo

namespace OnFirstPushToRepo {}

type Push

type Push = PushFieldsFragment;

type Subscription

type Subscription = OnFirstPushToRepoSubscription;

type Variables

type Variables = OnFirstPushToRepoSubscriptionVariables;

namespace OnIssueAction

namespace OnIssueAction {}

type Assignees

type Assignees = NonNullable<
    NonNullable<
        NonNullable<NonNullable<OnIssueActionSubscription['Issue']>[0]>['assignees']
    >[0]
>;

type Issue

type Issue = NonNullable<NonNullable<OnIssueActionSubscription['Issue']>[0]>;

type OpenedBy

type OpenedBy = NonNullable<
    NonNullable<NonNullable<OnIssueActionSubscription['Issue']>[0]>['openedBy']
>;

type Person

type Person = PersonFieldsFragment;

type Repo

type Repo = CoreRepoFieldsAndChannelsFragment;

type Subscription

type Subscription = OnIssueActionSubscription;

type Variables

type Variables = OnIssueActionSubscriptionVariables;

namespace OnNewIssue

namespace OnNewIssue {}

type Assignees

type Assignees = NonNullable<
    NonNullable<
        NonNullable<NonNullable<OnNewIssueSubscription['Issue']>[0]>['assignees']
    >[0]
>;

type Issue

type Issue = NonNullable<NonNullable<OnNewIssueSubscription['Issue']>[0]>;

type OpenedBy

type OpenedBy = NonNullable<
    NonNullable<NonNullable<OnNewIssueSubscription['Issue']>[0]>['openedBy']
>;

type Person

type Person = PersonFieldsFragment;

type Repo

type Repo = CoreRepoFieldsAndChannelsFragment;

type Subscription

type Subscription = OnNewIssueSubscription;

type Variables

type Variables = OnNewIssueSubscriptionVariables;

namespace OnPullRequest

namespace OnPullRequest {}

type Author

type Author = NonNullable<
    NonNullable<NonNullable<OnPullRequestSubscription['PullRequest']>[0]>['author']
>;

type Base

type Base = NonNullable<
    NonNullable<NonNullable<OnPullRequestSubscription['PullRequest']>[0]>['base']
>;

type Before

type Before = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<OnPullRequestSubscription['PullRequest']>[0]
                >['head']
            >['pushes']
        >[0]
    >['before']
>;

type Branch

type Branch = NonNullable<
    NonNullable<NonNullable<OnPullRequestSubscription['PullRequest']>[0]>['branch']
>;

type ChatId

type ChatId = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<OnPullRequestSubscription['PullRequest']>[0]
            >['author']
        >['person']
    >['chatId']
>;

type Commits

type Commits = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<
                        NonNullable<OnPullRequestSubscription['PullRequest']>[0]
                    >['head']
                >['pushes']
            >[0]
        >['commits']
    >[0]
>;

type Committer

type Committer = NonNullable<
    NonNullable<
        NonNullable<NonNullable<OnPullRequestSubscription['PullRequest']>[0]>['head']
    >['committer']
>;

type Head

type Head = NonNullable<
    NonNullable<NonNullable<OnPullRequestSubscription['PullRequest']>[0]>['head']
>;

type Person

type Person = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<OnPullRequestSubscription['PullRequest']>[0]
        >['author']
    >['person']
>;

type PullRequest

type PullRequest = NonNullable<
    NonNullable<OnPullRequestSubscription['PullRequest']>[0]
>;

type Pushes

type Pushes = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<OnPullRequestSubscription['PullRequest']>[0]
            >['head']
        >['pushes']
    >[0]
>;

type Repo

type Repo = CoreRepoFieldsAndChannelsFragment;

type Subscription

type Subscription = OnPullRequestSubscription;

type Variables

type Variables = OnPullRequestSubscriptionVariables;

namespace OnPushToAnyBranch

namespace OnPushToAnyBranch {}

type Push

type Push = PushFieldsFragment;

type Subscription

type Subscription = OnPushToAnyBranchSubscription;

type Variables

type Variables = OnPushToAnyBranchSubscriptionVariables;

namespace OnRepoCreation

namespace OnRepoCreation {}

type Repo

type Repo = NonNullable<NonNullable<OnRepoCreationSubscription['Repo']>[0]>;

type Subscription

type Subscription = OnRepoCreationSubscription;

type Variables

type Variables = OnRepoCreationSubscriptionVariables;

namespace OnRepoOnboarded

namespace OnRepoOnboarded {}

type Repo

type Repo = CoreRepoFieldsAndChannelsFragment;

type RepoOnboarded

type RepoOnboarded = NonNullable<
    NonNullable<OnRepoOnboardedSubscription['RepoOnboarded']>[0]
>;

type Subscription

type Subscription = OnRepoOnboardedSubscription;

type Variables

type Variables = OnRepoOnboardedSubscriptionVariables;

namespace OnSpecificCanceledSdmGoal

namespace OnSpecificCanceledSdmGoal {}

type SdmGoal

type SdmGoal = NonNullable<
    NonNullable<OnSpecificCanceledSdmGoalSubscription['SdmGoal']>[0]
>;

type Subscription

type Subscription = OnSpecificCanceledSdmGoalSubscription;

type Variables

type Variables = OnSpecificCanceledSdmGoalSubscriptionVariables;

namespace OnSuccessStatus

namespace OnSuccessStatus {}

type Commit

type Commit = NonNullable<
    NonNullable<NonNullable<OnSuccessStatusSubscription['Status']>[0]>['commit']
>;

type Pushes

type Pushes = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<OnSuccessStatusSubscription['Status']>[0]
            >['commit']
        >['pushes']
    >[0]
>;

type Repo

type Repo = CoreRepoFieldsAndChannelsFragment;

type Status

type Status = NonNullable<NonNullable<OnSuccessStatusSubscription['Status']>[0]>;

type Statuses

type Statuses = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<OnSuccessStatusSubscription['Status']>[0]
            >['commit']
        >['statuses']
    >[0]
>;

type Subscription

type Subscription = OnSuccessStatusSubscription;

type Variables

type Variables = OnSuccessStatusSubscriptionVariables;

namespace OnTag

namespace OnTag {}

type Commit

type Commit = NonNullable<
    NonNullable<NonNullable<OnTagSubscription['Tag']>[0]>['commit']
>;

type Release

type Release = NonNullable<
    NonNullable<NonNullable<OnTagSubscription['Tag']>[0]>['release']
>;

type Repo

type Repo = CoreRepoFieldsAndChannelsFragment;

type Subscription

type Subscription = OnTagSubscription;

type Tag

type Tag = NonNullable<NonNullable<OnTagSubscription['Tag']>[0]>;

type Variables

type Variables = OnTagSubscriptionVariables;

namespace OnUserJoiningChannel

namespace OnUserJoiningChannel {}

type Channel

type Channel = NonNullable<
    NonNullable<
        NonNullable<OnUserJoiningChannelSubscription['UserJoinedChannel']>[0]
    >['channel']
>;

type Person

type Person = PersonFieldsFragment;

type Repos

type Repos = CoreRepoFieldsAndChannelsFragment;

type Subscription

type Subscription = OnUserJoiningChannelSubscription;

type User

type User = NonNullable<
    NonNullable<
        NonNullable<OnUserJoiningChannelSubscription['UserJoinedChannel']>[0]
    >['user']
>;

type UserJoinedChannel

type UserJoinedChannel = NonNullable<
    NonNullable<OnUserJoiningChannelSubscription['UserJoinedChannel']>[0]
>;

type Variables

type Variables = OnUserJoiningChannelSubscriptionVariables;

namespace Password

namespace Password {}

type Owner

type Owner = NonNullable<NonNullable<PasswordQuery['Password']>[0]>['owner'];

type Password

type Password = NonNullable<NonNullable<PasswordQuery['Password']>[0]>;

type Query

type Query = PasswordQuery;

type Variables

type Variables = PasswordQueryVariables;

namespace PersonByChatId

namespace PersonByChatId {}

type ChatId

type ChatId = NonNullable<NonNullable<PersonByChatIdQuery['ChatId']>[0]>;

type Person

type Person = PersonFieldsFragment;

type Query

type Query = PersonByChatIdQuery;

type Variables

type Variables = PersonByChatIdQueryVariables;

namespace PersonFields

namespace PersonFields {}

type ChatId

type ChatId = NonNullable<PersonFieldsFragment['chatId']>;

type ChatTeam

type ChatTeam = NonNullable<NonNullable<PersonFieldsFragment['chatId']>['chatTeam']>;

type Emails

type Emails = NonNullable<NonNullable<PersonFieldsFragment['emails']>[0]>;

type Fragment

type Fragment = PersonFieldsFragment;

type GitHubId

type GitHubId = NonNullable<PersonFieldsFragment['gitHubId']>;

namespace PersonQuery

namespace PersonQuery {}

type ChatId

type ChatId = NonNullable<NonNullable<PersonQueryQuery['ChatId']>[0]>;

type Person

type Person = PersonFieldsFragment;

type Query

type Query = PersonQueryQuery;

type Variables

type Variables = PersonQueryQueryVariables;

namespace PullRequestForSha

namespace PullRequestForSha {}

type Author

type Author = NonNullable<
    NonNullable<NonNullable<PullRequestForShaQuery['PullRequest']>[0]>['author']
>;

type Base

type Base = NonNullable<
    NonNullable<NonNullable<PullRequestForShaQuery['PullRequest']>[0]>['base']
>;

type ChatId

type ChatId = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<PullRequestForShaQuery['PullRequest']>[0]
            >['author']
        >['person']
    >['chatId']
>;

type Head

type Head = NonNullable<
    NonNullable<NonNullable<PullRequestForShaQuery['PullRequest']>[0]>['head']
>;

type Person

type Person = NonNullable<
    NonNullable<
        NonNullable<NonNullable<PullRequestForShaQuery['PullRequest']>[0]>['author']
    >['person']
>;

type PullRequest

type PullRequest = NonNullable<
    NonNullable<PullRequestForShaQuery['PullRequest']>[0]
>;

type Query

type Query = PullRequestForShaQuery;

type Repo

type Repo = CoreRepoFieldsAndChannelsFragment;

type Variables

type Variables = PullRequestForShaQueryVariables;

namespace PullRequestsForBranch

namespace PullRequestsForBranch {}

type Branches

type Branches = NonNullable<
    NonNullable<
        NonNullable<NonNullable<PullRequestsForBranchQuery['Repo']>[0]>['branches']
    >[0]
>;

type PullRequests

type PullRequests = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<PullRequestsForBranchQuery['Repo']>[0]
                >['branches']
            >[0]
        >['pullRequests']
    >[0]
>;

type Query

type Query = PullRequestsForBranchQuery;

type Repo

type Repo = NonNullable<NonNullable<PullRequestsForBranchQuery['Repo']>[0]>;

type Variables

type Variables = PullRequestsForBranchQueryVariables;

namespace PushFields

namespace PushFields {}

type After

type After = NonNullable<PushFieldsFragment['after']>;

type Author

type Author = NonNullable<NonNullable<PushFieldsFragment['after']>['author']>;

type Before

type Before = NonNullable<PushFieldsFragment['before']>;

type Commits

type Commits = NonNullable<NonNullable<PushFieldsFragment['commits']>[0]>;

type Committer

type Committer = NonNullable<NonNullable<PushFieldsFragment['before']>['committer']>;

type Emails

type Emails = NonNullable<
    NonNullable<
        NonNullable<NonNullable<PushFieldsFragment['after']>['author']>['emails']
    >[0]
>;

type Fragment

type Fragment = PushFieldsFragment;

type Image

type Image = NonNullable<NonNullable<PushFieldsFragment['after']>['image']>;

type Images

type Images = NonNullable<
    NonNullable<NonNullable<PushFieldsFragment['after']>['images']>[0]
>;

type Person

type Person = PersonFieldsFragment;

type Release

type Release = NonNullable<
    NonNullable<
        NonNullable<NonNullable<PushFieldsFragment['after']>['tags']>[0]
    >['release']
>;

type Repo

type Repo = CoreRepoFieldsAndChannelsFragment;

type Tags

type Tags = NonNullable<
    NonNullable<NonNullable<PushFieldsFragment['after']>['tags']>[0]
>;

namespace PushForCommit

namespace PushForCommit {}

type Commit

type Commit = NonNullable<NonNullable<PushForCommitQuery['Commit']>[0]>;

type Org

type Org = NonNullable<
    NonNullable<
        NonNullable<NonNullable<PushForCommitQuery['Commit']>[0]>['repo']
    >['org']
>;

type Provider

type Provider = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<NonNullable<PushForCommitQuery['Commit']>[0]>['repo']
        >['org']
    >['provider']
>;

type Pushes

type Pushes = PushFieldsFragment;

type Query

type Query = PushForCommitQuery;

type Repo

type Repo = NonNullable<
    NonNullable<NonNullable<PushForCommitQuery['Commit']>[0]>['repo']
>;

type Variables

type Variables = PushForCommitQueryVariables;

namespace PushForSdmGoal

namespace PushForSdmGoal {}

type After

type After = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<NonNullable<PushForSdmGoalQuery['Commit']>[0]>['pushes']
        >[0]
    >['after']
>;

type Author

type Author = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<
                        NonNullable<PushForSdmGoalQuery['Commit']>[0]
                    >['pushes']
                >[0]
            >['commits']
        >[0]
    >['author']
>;

type Before

type Before = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<NonNullable<PushForSdmGoalQuery['Commit']>[0]>['pushes']
        >[0]
    >['before']
>;

type Channels

type Channels = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<
                        NonNullable<PushForSdmGoalQuery['Commit']>[0]
                    >['pushes']
                >[0]
            >['repo']
        >['channels']
    >[0]
>;

type Commit

type Commit = NonNullable<NonNullable<PushForSdmGoalQuery['Commit']>[0]>;

type Commits

type Commits = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<NonNullable<PushForSdmGoalQuery['Commit']>[0]>['pushes']
            >[0]
        >['commits']
    >[0]
>;

type Committer

type Committer = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<NonNullable<PushForSdmGoalQuery['Commit']>[0]>['pushes']
            >[0]
        >['before']
    >['committer']
>;

type Org

type Org = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<NonNullable<PushForSdmGoalQuery['Commit']>[0]>['pushes']
            >[0]
        >['repo']
    >['org']
>;

type Person

type Person = PersonFieldsFragment;

type Provider

type Provider = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<
                        NonNullable<PushForSdmGoalQuery['Commit']>[0]
                    >['pushes']
                >[0]
            >['repo']
        >['org']
    >['provider']
>;

type Pushes

type Pushes = NonNullable<
    NonNullable<
        NonNullable<NonNullable<PushForSdmGoalQuery['Commit']>[0]>['pushes']
    >[0]
>;

type Query

type Query = PushForSdmGoalQuery;

type Repo

type Repo = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<NonNullable<PushForSdmGoalQuery['Commit']>[0]>['pushes']
        >[0]
    >['repo']
>;

type Team

type Team = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<
                        NonNullable<
                            NonNullable<PushForSdmGoalQuery['Commit']>[0]
                        >['pushes']
                    >[0]
                >['repo']
            >['channels']
        >[0]
    >['team']
>;

type Variables

type Variables = PushForSdmGoalQueryVariables;

namespace RepoBranchTips

namespace RepoBranchTips {}

type Branches

type Branches = NonNullable<
    NonNullable<
        NonNullable<NonNullable<RepoBranchTipsQuery['Repo']>[0]>['branches']
    >[0]
>;

type Commit

type Commit = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<NonNullable<RepoBranchTipsQuery['Repo']>[0]>['branches']
        >[0]
    >['commit']
>;

type Org

type Org = NonNullable<
    NonNullable<NonNullable<RepoBranchTipsQuery['Repo']>[0]>['org']
>;

type Provider

type Provider = NonNullable<
    NonNullable<
        NonNullable<NonNullable<RepoBranchTipsQuery['Repo']>[0]>['org']
    >['provider']
>;

type Query

type Query = RepoBranchTipsQuery;

type Repo

type Repo = NonNullable<NonNullable<RepoBranchTipsQuery['Repo']>[0]>;

type Variables

type Variables = RepoBranchTipsQueryVariables;

namespace RepoScmProvider

namespace RepoScmProvider {}

type Branches

type Branches = NonNullable<
    NonNullable<
        NonNullable<NonNullable<RepoScmProviderQuery['Repo']>[0]>['branches']
    >[0]
>;

type Org

type Org = NonNullable<
    NonNullable<NonNullable<RepoScmProviderQuery['Repo']>[0]>['org']
>;

type Query

type Query = RepoScmProviderQuery;

type Repo

type Repo = NonNullable<NonNullable<RepoScmProviderQuery['Repo']>[0]>;

type ScmProvider

type ScmProvider = ScmProviderFieldsFragment;

type Variables

type Variables = RepoScmProviderQueryVariables;

namespace ReposInTeam

namespace ReposInTeam {}

type ChatTeam

type ChatTeam = NonNullable<NonNullable<ReposInTeamQuery['ChatTeam']>[0]>;

type Org

type Org = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<NonNullable<ReposInTeamQuery['ChatTeam']>[0]>['orgs']
                >[0]
            >['repo']
        >[0]
    >['org']
>;

type Orgs

type Orgs = NonNullable<
    NonNullable<NonNullable<NonNullable<ReposInTeamQuery['ChatTeam']>[0]>['orgs']>[0]
>;

type Provider

type Provider = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<
                        NonNullable<
                            NonNullable<ReposInTeamQuery['ChatTeam']>[0]
                        >['orgs']
                    >[0]
                >['repo']
            >[0]
        >['org']
    >['provider']
>;

type Query

type Query = ReposInTeamQuery;

type Repo

type Repo = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<NonNullable<ReposInTeamQuery['ChatTeam']>[0]>['orgs']
            >[0]
        >['repo']
    >[0]
>;

type Variables

type Variables = ReposInTeamQueryVariables;

namespace RepositoryByOwnerAndName

namespace RepositoryByOwnerAndName {}

type Org

type Org = NonNullable<
    NonNullable<NonNullable<RepositoryByOwnerAndNameQuery['Repo']>[0]>['org']
>;

type Provider

type Provider = NonNullable<
    NonNullable<
        NonNullable<NonNullable<RepositoryByOwnerAndNameQuery['Repo']>[0]>['org']
    >['provider']
>;

type Query

type Query = RepositoryByOwnerAndNameQuery;

type Repo

type Repo = NonNullable<NonNullable<RepositoryByOwnerAndNameQuery['Repo']>[0]>;

type Variables

type Variables = RepositoryByOwnerAndNameQueryVariables;

namespace RepositoryMappedChannels

namespace RepositoryMappedChannels {}

type ChatChannel

type ChatChannel = NonNullable<
    NonNullable<RepositoryMappedChannelsQuery['ChatChannel']>[0]
>;

type Org

type Org = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<RepositoryMappedChannelsQuery['ChatChannel']>[0]
            >['repos']
        >[0]
    >['org']
>;

type Provider

type Provider = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<
                NonNullable<
                    NonNullable<RepositoryMappedChannelsQuery['ChatChannel']>[0]
                >['repos']
            >[0]
        >['org']
    >['provider']
>;

type Query

type Query = RepositoryMappedChannelsQuery;

type Repos

type Repos = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<RepositoryMappedChannelsQuery['ChatChannel']>[0]
        >['repos']
    >[0]
>;

type Variables

type Variables = RepositoryMappedChannelsQueryVariables;

namespace ResourceUser

namespace ResourceUser {}

type ChatId

type ChatId = NonNullable<NonNullable<ResourceUserQuery['ChatId']>[0]>;

type Credential

type Credential = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<NonNullable<ResourceUserQuery['ChatId']>[0]>['person']
        >['gitHubId']
    >['credential']
>;

type GitHubId

type GitHubId = NonNullable<
    NonNullable<
        NonNullable<NonNullable<ResourceUserQuery['ChatId']>[0]>['person']
    >['gitHubId']
>;

type Person

type Person = NonNullable<
    NonNullable<NonNullable<ResourceUserQuery['ChatId']>[0]>['person']
>;

type Query

type Query = ResourceUserQuery;

type Variables

type Variables = ResourceUserQueryVariables;

namespace ResumeJob

namespace ResumeJob {}

type Mutation

type Mutation = ResumeJobMutation;

type ResumeAtmJob

type ResumeAtmJob = NonNullable<ResumeJobMutation['resumeAtmJob']>;

type Variables

type Variables = ResumeJobMutationVariables;

namespace ScmProvider

namespace ScmProvider {}

type Credential

type Credential = NonNullable<
    NonNullable<NonNullable<ScmProviderQuery['SCMProvider']>[0]>['credential']
>;

type Query

type Query = ScmProviderQuery;

type ScmProvider

type ScmProvider = NonNullable<NonNullable<ScmProviderQuery['SCMProvider']>[0]>;

type Variables

type Variables = ScmProviderQueryVariables;

namespace ScmProviderByType

namespace ScmProviderByType {}

type Credential

type Credential = NonNullable<
    NonNullable<NonNullable<ScmProviderByTypeQuery['SCMProvider']>[0]>['credential']
>;

type Query

type Query = ScmProviderByTypeQuery;

type ScmProvider

type ScmProvider = NonNullable<
    NonNullable<ScmProviderByTypeQuery['SCMProvider']>[0]
>;

type Variables

type Variables = ScmProviderByTypeQueryVariables;

namespace ScmProviderFields

namespace ScmProviderFields {}

type Credential

type Credential = NonNullable<ScmProviderFieldsFragment['credential']>;

type Fragment

type Fragment = ScmProviderFieldsFragment;

namespace ScmProviders

namespace ScmProviders {}

type Query

type Query = ScmProvidersQuery;

type ScmProvider

type ScmProvider = ScmProviderFieldsFragment;

type Variables

type Variables = ScmProvidersQueryVariables;

namespace SdmGoalByShaAndBranch

namespace SdmGoalByShaAndBranch {}

type Approval

type Approval = NonNullable<
    NonNullable<NonNullable<SdmGoalByShaAndBranchQuery['SdmGoal']>[0]>['approval']
>;

type Descriptions

type Descriptions = NonNullable<
    NonNullable<
        NonNullable<SdmGoalByShaAndBranchQuery['SdmGoal']>[0]
    >['descriptions']
>;

type ExternalUrls

type ExternalUrls = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<SdmGoalByShaAndBranchQuery['SdmGoal']>[0]
        >['externalUrls']
    >[0]
>;

type Fulfillment

type Fulfillment = NonNullable<
    NonNullable<NonNullable<SdmGoalByShaAndBranchQuery['SdmGoal']>[0]>['fulfillment']
>;

type PreApproval

type PreApproval = NonNullable<
    NonNullable<NonNullable<SdmGoalByShaAndBranchQuery['SdmGoal']>[0]>['preApproval']
>;

type PreConditions

type PreConditions = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<SdmGoalByShaAndBranchQuery['SdmGoal']>[0]
        >['preConditions']
    >[0]
>;

type Provenance

type Provenance = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<SdmGoalByShaAndBranchQuery['SdmGoal']>[0]
        >['provenance']
    >[0]
>;

type Query

type Query = SdmGoalByShaAndBranchQuery;

type Repo

type Repo = NonNullable<
    NonNullable<NonNullable<SdmGoalByShaAndBranchQuery['SdmGoal']>[0]>['repo']
>;

type SdmGoal

type SdmGoal = NonNullable<NonNullable<SdmGoalByShaAndBranchQuery['SdmGoal']>[0]>;

type Variables

type Variables = SdmGoalByShaAndBranchQueryVariables;

namespace SdmGoalFields

namespace SdmGoalFields {}

type Approval

type Approval = NonNullable<SdmGoalFieldsFragment['approval']>;

type Descriptions

type Descriptions = NonNullable<SdmGoalFieldsFragment['descriptions']>;

type ExternalUrls

type ExternalUrls = NonNullable<
    NonNullable<SdmGoalFieldsFragment['externalUrls']>[0]
>;

type Fragment

type Fragment = SdmGoalFieldsFragment;

type Fulfillment

type Fulfillment = NonNullable<SdmGoalFieldsFragment['fulfillment']>;

type PreApproval

type PreApproval = NonNullable<SdmGoalFieldsFragment['preApproval']>;

type PreConditions

type PreConditions = NonNullable<
    NonNullable<SdmGoalFieldsFragment['preConditions']>[0]
>;

type Provenance

type Provenance = NonNullable<NonNullable<SdmGoalFieldsFragment['provenance']>[0]>;

type Push

type Push = PushFieldsFragment;

namespace SdmGoalRepo

namespace SdmGoalRepo {}

type Fragment

type Fragment = SdmGoalRepoFragment;

type Repo

type Repo = NonNullable<SdmGoalRepoFragment['repo']>;

namespace SdmGoalsByGoalSetIdAndUniqueName

namespace SdmGoalsByGoalSetIdAndUniqueName {}

type Query

type Query = SdmGoalsByGoalSetIdAndUniqueNameQuery;

type SdmGoal

type SdmGoal = SdmGoalRepoFragment;

type Variables

type Variables = SdmGoalsByGoalSetIdAndUniqueNameQueryVariables;

namespace SdmGoalSetFields

namespace SdmGoalSetFields {}

type Fragment

type Fragment = SdmGoalSetFieldsFragment;

type Goals

type Goals = NonNullable<NonNullable<SdmGoalSetFieldsFragment['goals']>[0]>;

type Provenance

type Provenance = NonNullable<SdmGoalSetFieldsFragment['provenance']>;

type Repo

type Repo = NonNullable<SdmGoalSetFieldsFragment['repo']>;

type Tags

type Tags = NonNullable<NonNullable<SdmGoalSetFieldsFragment['tags']>[0]>;

namespace SdmGoalSetForId

namespace SdmGoalSetForId {}

type Query

type Query = SdmGoalSetForIdQuery;

type SdmGoalSet

type SdmGoalSet = SdmGoalSetFieldsFragment;

type Variables

type Variables = SdmGoalSetForIdQueryVariables;

namespace SdmGoalsForCommit

namespace SdmGoalsForCommit {}

type Query

type Query = SdmGoalsForCommitQuery;

type Repo

type Repo = NonNullable<
    NonNullable<NonNullable<SdmGoalsForCommitQuery['SdmGoal']>[0]>['repo']
>;

type SdmGoal

type SdmGoal = SdmGoalFieldsFragment;

type Variables

type Variables = SdmGoalsForCommitQueryVariables;

namespace SdmGoalWithGoalsFields

namespace SdmGoalWithGoalsFields {}

type Approval

type Approval = NonNullable<SdmGoalWithGoalsFieldsFragment['approval']>;

type Descriptions

type Descriptions = NonNullable<SdmGoalWithGoalsFieldsFragment['descriptions']>;

type ExternalUrls

type ExternalUrls = NonNullable<
    NonNullable<SdmGoalWithGoalsFieldsFragment['externalUrls']>[0]
>;

type Fragment

type Fragment = SdmGoalWithGoalsFieldsFragment;

type Fulfillment

type Fulfillment = NonNullable<SdmGoalWithGoalsFieldsFragment['fulfillment']>;

type Goals

type Goals = SdmGoalRepoFragment;

type PreApproval

type PreApproval = NonNullable<SdmGoalWithGoalsFieldsFragment['preApproval']>;

type PreConditions

type PreConditions = NonNullable<
    NonNullable<SdmGoalWithGoalsFieldsFragment['preConditions']>[0]
>;

type Provenance

type Provenance = NonNullable<
    NonNullable<SdmGoalWithGoalsFieldsFragment['provenance']>[0]
>;

type Push

type Push = PushFieldsFragment;

namespace SdmPreferenceByKey

namespace SdmPreferenceByKey {}

type Query

type Query = SdmPreferenceByKeyQuery;

type SdmPreference

type SdmPreference = NonNullable<
    NonNullable<SdmPreferenceByKeyQuery['SdmPreference']>[0]
>;

type Variables

type Variables = SdmPreferenceByKeyQueryVariables;

namespace SdmVersionForCommit

namespace SdmVersionForCommit {}

type Query

type Query = SdmVersionForCommitQuery;

type Repo

type Repo = NonNullable<
    NonNullable<NonNullable<SdmVersionForCommitQuery['SdmVersion']>[0]>['repo']
>;

type SdmVersion

type SdmVersion = NonNullable<
    NonNullable<SdmVersionForCommitQuery['SdmVersion']>[0]
>;

type Variables

type Variables = SdmVersionForCommitQueryVariables;

namespace SetJobTaskState

namespace SetJobTaskState {}

type Mutation

type Mutation = SetJobTaskStateMutation;

type SetAtmJobTaskState

type SetAtmJobTaskState = NonNullable<SetJobTaskStateMutation['setAtmJobTaskState']>;

type Variables

type Variables = SetJobTaskStateMutationVariables;

namespace SetResourceProviderState

namespace SetResourceProviderState {}

type Mutation

type Mutation = SetResourceProviderStateMutation;

type SetResourceProviderState

type SetResourceProviderState =
    SetResourceProviderStateMutation['setResourceProviderState'];

type Variables

type Variables = SetResourceProviderStateMutationVariables;

namespace SetTeamConfiguration

namespace SetTeamConfiguration {}

type Mutation

type Mutation = SetTeamConfigurationMutation;

type SetTeamConfiguration

type SetTeamConfiguration = SetTeamConfigurationMutation['setTeamConfiguration'];

type Variables

type Variables = SetTeamConfigurationMutationVariables;

namespace spdx-license-list

module 'spdx-license-list' {}

variable L

const L: Record<string, LicenseInfo>;

namespace TeamConfigurationByNamespace

namespace TeamConfigurationByNamespace {}

type Query

type Query = TeamConfigurationByNamespaceQuery;

type TeamConfiguration

type TeamConfiguration = NonNullable<
    NonNullable<TeamConfigurationByNamespaceQuery['TeamConfiguration']>[0]
>;

type Variables

type Variables = TeamConfigurationByNamespaceQueryVariables;

namespace UpdateSdmGoal

namespace UpdateSdmGoal {}

type Mutation

type Mutation = UpdateSdmGoalMutation;

type Variables

type Variables = UpdateSdmGoalMutationVariables;

namespace UpdateSdmGoalSet

namespace UpdateSdmGoalSet {}

type Mutation

type Mutation = UpdateSdmGoalSetMutation;

type Variables

type Variables = UpdateSdmGoalSetMutationVariables;

namespace UpdateSdmVersion

namespace UpdateSdmVersion {}

type Mutation

type Mutation = UpdateSdmVersionMutation;

type Variables

type Variables = UpdateSdmVersionMutationVariables;

namespace WhatIsRunning

namespace WhatIsRunning {}

type Application

type Application = NonNullable<NonNullable<WhatIsRunningQuery['Application']>[0]>;

type Commits

type Commits = NonNullable<
    NonNullable<
        NonNullable<NonNullable<WhatIsRunningQuery['Application']>[0]>['commits']
    >[0]
>;

type Query

type Query = WhatIsRunningQuery;

type Repo

type Repo = NonNullable<
    NonNullable<
        NonNullable<
            NonNullable<NonNullable<WhatIsRunningQuery['Application']>[0]>['commits']
        >[0]
    >['repo']
>;

type Variables

type Variables = WhatIsRunningQueryVariables;

Package Files (218)

Dependencies (65)

Dev Dependencies (18)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@atomist/sdm.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@atomist/sdm)

HTML

<a href="https://www.jsdocs.io/package/@atomist/sdm"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 2 years ago.
Package analyzed in 36080 ms.
Missing or incorrect documentation? Open an issue for this package.

@atomist/sdm

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable AddressNoChannels

variable and

variable AnyPush

Parameter p

variable ApproveGoalIfErrorComments

variable ApproveGoalIfWarnComments

variable AtomistContinuationMimeType

variable AutofixProgressReporter

variable AutofixProgressTests

variable BaseContext

variable CFamilyLanguageSourceFiles

variable CloningProjectLoader

variable createEphemeralProgressLog

variable DefaultCancelOptions

variable DefaultExtractAuthor

variable DefaultGoalNameGenerator

variable DefaultMockOptions

variable DefaultPredicateMappingCostAnalyzer

Parameter pm

variable DefaultQueueOptions

variable DoNotSetAnyGoals

variable DoNotSetAnyGoalsAndLock

variable DryRunParameter

variable FailGoalIfErrorComments

variable FailGoalIfWarnComments

variable FromAtomist

Parameter p

variable GeneratorTag

variable GitBranchRegExp

variable GitHubNameRegExp

variable githubTeamVoter

Deprecated

variable GitShaRegExp

variable GoalSetGoalCompletionListener

Parameter gcl

variable HasTravisFile

variable Immaterial

variable ImmaterialGoals

variable IndependentOfEnvironment

variable InspectionTag

variable IsDeployEnabled

Parameter pi

variable IsPushToBranchWithPullRequest

variable JobDescriptionParameter

variable JobNameParameter

variable JobRequiredParameter

variable Locking

variable LogSuppressor

variable MsgIdParameter

variable NamedSeedRepo

Parameter pi

variable NonEmpty

variable NoOpExtractAuthor

variable NoParameterPrompt

variable NoPreferenceStore

variable NoProgressReport

variable not

variable or

variable ProductionEnvironment

variable ProjectDisposalEnvironment

variable SemVerRegExp

variable ServiceRegistrationGoalDataKey

variable StagingEnvironment

variable SuccessIsReturn0ErrorFinder

Parameter code

variable ToDefaultBranch

variable TransformTag

variable UnanimousGoalApprovalRequestVoteDecisionManager