@atomist/sdm

@atomist/sdm

Version 2.1.6
Published 4 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

@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