const makeControlString = (type: string) => `[WIZARD_CONTROL] ${type}`

export const WIZARD_RETRY = {

export const WIZARD_BACK = { id: WIZARD_CONTROL, type: ControlSignal.Back, toString: () => makeControlString('Back') }

export const WIZARD_EXIT = { id: WIZARD_CONTROL, type: ControlSignal.Exit, toString: () => makeControlString('Exit') }

import { ChildNodeCache } from './childNodeCache'

import * as AsyncLock from 'async-lock'

    private async loadMoreChildrenIf(condition: () => boolean): Promise<void> {

        if (condition()) {

                if (condition()) {

                    const newPage = await this.loadPage(this.cache.continuationToken)

                    this.cache.appendPage(newPage)

import { Timeout, waitTimeout } from '../shared/utilities/timeoutUtils'

import { fromExtensionManifest } from '../shared/settings'

export function asEnvironmentVariables(credentials: Credentials): NodeJS.ProcessEnv {

    const environmentVariables: NodeJS.ProcessEnv = {}

export async function resolveProviderWithCancel(

    if (typeof timeout === 'number') {

        timeout = new Timeout(timeout)

    return await waitTimeout(provider, timeout, {

async function getLanguageServerDebuggerPort(extensionContext: ExtensionContext): Promise<number> {

    const env = process.env as EnvironmentVariables

    const port = env.SSMDOCUMENT_LANGUAGESERVER_PORT

    return getPortPromise({ port: port })

    window: Window = Window.vscode()

    if (!cliToInstall) {

    progress.report({ message: msgDownloading })

    const outDir = path.join(getToolkitLocalCliPath(), 'sessionmanagerplugin')

    const TimedProcess = ChildProcess.extend({ timeout, rejectOnError: true, rejectOnErrorCode: true })

    getLogger('channel').info(`Installing SSM CLI from ${ssmInstaller} to ${outDir}...`)

            req = EditorContext.buildListRecommendationRequest(

            req = EditorContext.buildGenerateRecommendationRequest(editor as vscode.TextEditor)

        this.nextToken = ''

        this.errorMessagePrompt = ''

        TelemetryHelper.instance.recordUserDecisionTelemetry(

import { DevSettings } from '../settings'

export enum AccountStatus {

    NotApplicable = 'n/a',

    Invalid = 'invalid',

export class DefaultTelemetryClient implements TelemetryClient {

    private static initializeConfig(): TelemetryConfiguration {

        const settings = DevSettings.instance

        return {

import { DefaultCloudWatchLogsClient } from '../../shared/clients/cloudWatchLogsClient'

const localize = nls.loadMessageBundle()

export class AppRunnerServiceNode extends CloudWatchLogsBase implements AWSResourceNode {

    private setLabel(): void {

        const displayStatus = this.currentOperation.Type

            : `${this._info.Status.charAt(0)}${this._info.Status.slice(1).toLowerCase().replace(/\_/g, ' ')}`

        this.label = `${this._info.ServiceName} [${displayStatus}]`

        this._info = Object.assign(this._info, info)

        this.setLabel()

import { RuntimeFamily } from '../../../lambda/models/samLambdaRuntime'

import { sleep } from '../../utilities/timeoutUtils'

import { runLambdaFunction, waitForPort } from '../localLambdaRunner'

export async function invokeJavaLambda(ctx: ExtContext, config: SamLaunchRequestArgs): Promise<SamLaunchRequestArgs> {

import { getIdeProperties, isCloud9 } from '../extensionUtilities'

    public get defaultRegionId() {

    public static readonly NO_ITEMS_ITEM: vscode.QuickPickItem = {

    public static readonly ERROR_ITEM: vscode.QuickPickItem = {

export async function resumeCreateNewSamApp(

    try {

        const configString: string = configurations.reduce((acc, cur) => `${acc}\n* ${cur.name}`, '')

export function getDefaultRuntime(runtime: RuntimeFamily): string | undefined {

import { Commands } from '../vscode/commands2'

import globals from '../extensionGlobals'

    try {

        const registry = new CloudFormationTemplateRegistry()

        globals.templateRegistry = registry

        await registry.watchUntitledFiles()

import * as vscode from 'vscode'

import * as path from 'path'

import { DevEnvClient } from '../shared/clients/devenvClient'

import { getLogger } from '../shared/logger'

import { Commands } from '../shared/vscode/commands2'

import { checkUnsavedChanges } from '../shared/utilities/workspaceUtils'

export function registerDevfileWatcher(devenvClient: DevEnvClient): vscode.Disposable {

import { Commands } from '../../shared/vscode/commands'

import { getIcon } from '../../shared/icons'

const sfnNodeMap = new Map<string, StepFunctionsNode>()

    details: StepFunctions.StateMachineListItem

    const node = new StateMachineNode(parent, regionCode, details)

    return node

        const start = acceptanceEntry.range.start

        const end = isCloud9() ? acceptanceEntry.editor.selection.active : acceptanceEntry.range.end

        const languageId = acceptanceEntry.editor.document.languageId

export function isExpired(expirable: { expiresAt: Date }): boolean {

export function createInputBox(options?: ExtendedInputBoxOptions): InputBoxPrompter {

    const inputBox = vscode.window.createInputBox() as InputBox

    inputBox.buttons = options?.buttons ?? []

    const prompter = new InputBoxPrompter(inputBox)

        this.inputBox.onDidChangeValue(

            value => (this.inputBox.validationMessage = validate(value)),

        this.inputBox.onDidAccept(

            () => (this.inputBox.validationMessage = validate(this.inputBox.value)),

import { YAML_FORMATS } from '../../constants/aslFormats'

import globals from '../../../shared/extensionGlobals'

        let yamlErrors: string[] = []

        if (isYaml) {

            yamlErrors = parsed.errors.map(error => error.message)

const execFileAsync = promisify(execFile)

import { LambdaFunctionNode } from './lambdaFunctionNode'

import { samLambdaImportableRuntimes } from '../models/samLambdaRuntime'

    const node = new LambdaFunctionNode(parent, regionCode, configuration)

    node.contextValue = samLambdaImportableRuntimes.contains(node.configuration.Runtime ?? '')

    return node

import { DefaultS3Client } from '../../../shared/clients/s3Client'

import { telemetry } from '../../../shared/telemetry/telemetry'

export class ResourceTypeNode extends AWSTreeNodeBase implements LoadMoreNode {

    private readonly childLoader: ChildNodeLoader = new ChildNodeLoader(this, token => this.loadPage(token))

        this.tooltip = typeName

        const supportedOperations = metadata.operations

        if (!metadata.available) {

            this.contextValue = 'UnavailableResourceTypeNode'

            const documentedContextValue = metadata.documentation ? 'Documented' : ''

            const createContextValue = supportedOperations.includes('Creatable') ? 'Creatable' : ''

            this.contextValue = `${documentedContextValue}${createContextValue}ResourceTypeNode`

    public async getChildren(): Promise<AWSTreeNodeBase[]> {

                    getLogger().warn(

                    result = 'Failed'

                    return new TreeShim(createErrorItem(error, `Resources: unexpected error: ${error.message}`))

import globals from '../extensionGlobals'

        const output: Iot.ListThingsResponse = await iot

                nextToken: request?.nextToken,

        const output: Iot.ListCertificatesResponse = await iot

        const output: Iot.ListThingPrincipalsResponse = await iot

        const describedCerts = iotPrincipals.map(async iotPrincipal => {

            const principalArn = parse(iotPrincipal)

            const certId = certIdFound[1]

        const output = await iot

        const output: Iot.ListPoliciesResponse = await iot

        const output: Iot.ListPrincipalPoliciesResponse = await iot

        const output = await iot

        getLogger().debug('GetEndpoint called')

        const iot = await this.iotProvider(this.regionCode)

        if (!output.endpointAddress) {