Module runtime

const getFunctionLocationAsync: getFunctionLocationAsync =  versionSpecificV8Module.getFunctionLocationAsync;

Given a function, returns the file, line and column number in the file where this function was defined. Returns { “”, 0, 0 } if the location cannot be found or if the given function has no Script.

const lookupCapturedVariableValueAsync: lookupCapturedVariableValueAsync =  versionSpecificV8Module.lookupCapturedVariableValueAsync;

Given a function and a free variable name, lookupCapturedVariableValue looks up the value of that free variable in the scope chain of the provided function. If the free variable is not found, throwOnFailure indicates whether or not this function should throw or return `undefined.

const rootPulumiStackTypeName: "pulumi:pulumi:Stack" = "pulumi:pulumi:Stack";

rootPulumiStackTypeName is the type name that should be used to construct the root component in the tree of Pulumi resources allocated by a deployment. This must be kept up to date with github.com/pulumi/pulumi/pkg/resource/stack.RootPulumiStackTypeName.

const specialArchiveSig: "0def7320c3a5731c473e5ecbe6d01bc7" = "0def7320c3a5731c473e5ecbe6d01bc7";

specialArchiveSig is a randomly assigned hash used to identify archives in maps. See pkg/resource/asset.go.

const specialAssetSig: "c44067f5952c0a294b673a41bacd8c17" = "c44067f5952c0a294b673a41bacd8c17";

specialAssetSig is a randomly assigned hash used to identify assets in maps. See pkg/resource/asset.go.

const specialSecretSig: "1b47061264138c4ac30d75fd1eb44270" = "1b47061264138c4ac30d75fd1eb44270";

specialSecretSig is a randomly assigned hash used to identify secrets in maps. See pkg/resource/properties.go.

const specialSigKey: "4dabf18193072939515e22adb298388d" = "4dabf18193072939515e22adb298388d";

specialSigKey is sometimes used to encode type identity inside of a map. See pkg/resource/properties.go.

const unknownValue: "04da6b54-80e4-46f7-96ec-b56ff0331ba9" = "04da6b54-80e4-46f7-96ec-b56ff0331ba9";

Unknown values are encoded as a distinguished string value.

allConfig(): {[key: string]: string}

allConfig returns a copy of the full config map.

createFunctionInfoAsync(func: Function, serialize: (o: any) => boolean, logResource: resource.Resource | undefined): Promise<FunctionInfo>

createFunctionInfo serializes a function and its closure environment into a form that is amenable to persistence as simple JSON. Like toString, it includes the full text of the function’s source code, suitable for execution. Unlike toString, it actually includes information about the captured environment.

debuggablePromise<T>(p: Promise<T>, ctx: any): Promise<T>

debuggablePromise optionally wraps a promise with some goo to make it easier to debug common problems.

deserializeProperties(outputsStruct: any): any

deserializeProperties fetches the raw outputs and deserializes them from a gRPC call result.

deserializeProperty(prop: any): any

deserializeProperty unpacks some special types, reversing the above process.

disconnect(): void

disconnect permanently disconnects from the server, closing the connections. It waits for the existing RPC queue to drain. If any RPCs come in afterwards, however, they will crash the process.

disconnectSync(): void

disconnectSync permanently disconnects from the server, closing the connections. Unlike disconnect. it does not wait for the existing RPC queue to drain. Any RPCs that come in after this call will crash the process.

errorString(err: Error): string

errorString produces a string from an error, conditionally including additional diagnostics.

getConfig(k: string): string | undefined

getConfig returns a configuration variable’s value or undefined if it is unset.

getEngine(): Object | undefined

getEngine returns the current engine, if any, for RPC communications back to the resource engine.

getMonitor(): Object

getMonitor returns the current resource monitoring service client for RPC communications.

getProject(): string | undefined

Get the project being run by the current update.

getRootResource(): Promise<URN | undefined>

getRootResource returns a root resource URN that will automatically become the default parent of all resources. This can be used to ensure that all resources without explicit parents are parented to a common parent resource.

getStack(): string | undefined

Get the stack being targeted by the current update.

hasMonitor(): boolean

hasMonitor returns true if we are currently connected to a resource monitoring service.

invoke(tok: string, props: Inputs, opts?: InvokeOptions): Promise<any>

invoke dynamically invokes the function, tok, which is offered by a provider plugin. The inputs can be a bag of computed values (Ts or Promises), and the result is a Promise that resolves when the invoke finishes.

isDryRun(): boolean

Returns true if we’re currently performing a dry-run, or false if this is a true update.

parseFunction(funcString: string): [, string, ParsedFunction]

readResource(res: Resource, t: string, name: string, props: Inputs, opts: ResourceOptions): void

Reads an existing custom resource’s state from the resource monitor. Note that resources read in this way will not be part of the resulting stack’s state, as they are presumed to belong to another.

registerResource(res: Resource, t: string, name: string, custom: boolean, props: Inputs, opts: ResourceOptions): void

registerResource registers a new resource object with a given type t and name. It returns the auto-generated URN and the ID that will resolve after the deployment has completed. All properties will be initialized to property objects that the registration operation will resolve at the right time (or remain unresolved for deployments).

registerResourceOutputs(res: Resource, outputs: Inputs | Promise<Inputs> | Output<Inputs>): void

registerResourceOutputs completes the resource registration, attaching an optional set of computed outputs.

resolveProperties(res: Resource, resolvers: Record<string, (v: any, isKnown: boolean) => void>, t: string, name: string, allProps: any): void

resolveProperties takes as input a gRPC serialized proto.google.protobuf.Struct and resolves all of the resource’s matching properties to the values inside.

NOTE: it is imperative that the properties in allProps were produced by deserializeProperties in order for output properties to work correctly w.r.t. knowns/unknowns: this function assumes that any undefined value in allPropsrepresents an unknown value that was returned by an engine operation.

rewriteSuperReferences(code: string, isStatic: boolean): string

rpcKeepAlive(): () => void

rpcKeepAlive registers a pending call to ensure that we don’t prematurely disconnect from the server. It returns a function that, when invoked, signals that the RPC has completed.

runInPulumiStack(init: () => any): Promise<Inputs | undefined>

runInPulumiStack creates a new Pulumi stack resource and executes the callback inside of it. Any outputs returned by the callback will be stored as output properties on this resulting Stack object.

serialize(): boolean

serialize returns true if resource operations should be serialized.

serializeFunction(func: Function, args: SerializeFunctionArgs): Promise<SerializedFunction>

serializeFunction serializes a JavaScript function into a text form that can be loaded in another execution context, for example as part of a function callback associated with an AWS Lambda. The function serialization captures any variables captured by the function body and serializes those values into the generated text along with the function body. This process is recursive, so that functions referenced by the body of the serialized function will themselves be serialized as well. This process also deeply serializes captured object values, including prototype chains and property descriptors, such that the semantics of the function when deserialized should match the original function.

There are several known limitations:

• If a native function is captured either directly or indirectly, closure serialization will return an error.
• Captured values will be serialized based on their values at the time that serializeFunction is called. Mutations to these values after that (but before the deserialized function is used) will not be observed by the deserialized function.

serializeFunctionAsync(func: Function, serialize?: undefined | (o: any) => boolean): Promise<string>

serializeProperties(label: string, props: Inputs, propertyDependencies: Record<string, Resource[]>): Promise<Record<string, any>>

serializeProperties walks the props object passed in, awaiting all interior promises, creating a reasonable POJO object that can be remoted over to registerResource.

serializeProperty(ctx: string, prop: Input<any>, dependentResources: Resource[]): Promise<any>

serializeProperty serializes properties deeply. This understands how to wait on any unresolved promises, as appropriate, in addition to translating certain “special” values so that they are ready to go on the wire.

serializeResourceProperties(label: string, props: Inputs, propertyDependencies: Record<string, Resource[]>): Promise<Record<string, any>>

serializeResourceProperties walks the props object passed in, awaiting all interior promises besides those for id and urn, creating a reasonable POJO object that can be remoted over to registerResource.

setConfig(k: string, v: string): void

setConfig sets a configuration variable.

setIsDryRun(val: boolean): void

setRootResource(res: ComponentResource): Promise<void>

setRootResource registers a resource that will become the default parent for all resources without explicit parents.

transferProperties(onto: Resource, label: string, props: Inputs): OutputResolvers

transferProperties mutates the ‘onto’ resource so that it has Promise-valued properties for all the ‘props’ input/output props. Importantly all these promises are completely unresolved. This is because we don’t want anyone to observe the values of these properties until the rpc call to registerResource actually returns. This is because the registerResource call may actually override input values, and we only want people to see the final value.

The result of this call (beyond the stateful changes to ‘onto’) is the set of Promise resolvers that will be called post-RPC call. When the registerResource RPC call comes back, the values that the engine actualy produced will be used to resolve all the unresolved promised placed on ‘onto’.

property infos

infos: CapturedPropertyInfo[];

property invoked

invoked: boolean;

property name

name: string;

property optional

optional: CapturedVariableMap;

property required

required: CapturedVariableMap;

Entry is the environment slot for a named lexically captured variable.

property array

array?: Entry[];

property expr

expr?: undefined | string;

property function

function?: FunctionInfo;

property json

json?: any;

property module

module?: undefined | string;

property object

object?: ObjectInfo;

property output

output?: Entry;

property promise

promise?: Entry;

property regexp

regexp?: undefined | {
    flags: string;
    source: string;
};

extends ObjectInfo

property capturedValues

capturedValues: PropertyMap;

property code

code: string;

property env

env: PropertyMap;

property name

name: string | undefined;

property proto

proto?: Entry;

property usesNonLexicalThis

usesNonLexicalThis: boolean;

property env

env: PropertyMap;

property proto

proto?: Entry;

Options is a bag of settings that controls the behavior of previews and deployments

property dryRun

dryRun?: undefined | false | true;

property engineAddr

engineAddr?: undefined | string;

property monitorAddr

monitorAddr?: undefined | string;

property parallel

parallel?: undefined | number;

property project

project?: undefined | string;

property stack

stack?: undefined | string;

extends ParsedFunctionCode

property capturedVariables

capturedVariables: CapturedVariables;

property funcExprWithName

funcExprWithName?: undefined | string;

property funcExprWithoutName

funcExprWithoutName: string;

property functionDeclarationName

functionDeclarationName?: undefined | string;

property isArrowFunction

isArrowFunction: boolean;

property usesNonLexicalThis

usesNonLexicalThis: boolean;

property funcExprWithName

funcExprWithName?: undefined | string;

property funcExprWithoutName

funcExprWithoutName: string;

property functionDeclarationName

functionDeclarationName?: undefined | string;

property isArrowFunction

isArrowFunction: boolean;

property configurable

configurable?: undefined | false | true;

property enumerable

enumerable?: undefined | false | true;

property get

get?: Entry;

property hasValue

hasValue: boolean;

property set

set?: Entry;

property writable

writable?: undefined | false | true;

property entry

entry: Entry;

property info

info?: PropertyInfo;

extends Map<Entry, PropertyInfoAndValue>

method __@iterator

__@iterator(): IterableIterator<[, Entry, PropertyInfoAndValue]>

method clear

clear(): void

method delete

delete(key: Entry): boolean

method entries

entries(): IterableIterator<[, Entry, PropertyInfoAndValue]>

method forEach

forEach(callbackfn: (value: PropertyInfoAndValue, key: Entry, map: Map<Entry, PropertyInfoAndValue>) => void, thisArg?: any): void

method get

get(key: Entry): PropertyInfoAndValue | undefined

method has

has(key: Entry): boolean

method keys

keys(): IterableIterator<Entry>

method set

set(key: Entry, value: PropertyInfoAndValue): this

method values

values(): IterableIterator<PropertyInfoAndValue>

property Map

Map: MapConstructor;

property __@toStringTag

__@toStringTag: "Map";

property size

size: number;

SerializeFunctionArgs are arguments used to serialize a JavaScript function

property exportName

exportName?: undefined | string;

property isFactoryFunction

isFactoryFunction?: undefined | false | true;

property logResource

logResource?: Resource;

property serialize

serialize?: undefined | (o: any) => boolean;

SerializeFunction is a representation of a serialized JavaScript function.

property exportName

exportName: string;

property text

text: string;

let excessiveDebugOutput: boolean = false;

excessiveDebugOutput enables, well, pretty excessive debug output pertaining to resources and properties.

type CapturedVariableMap = Map<string, CapturedPropertyChain[]>;

type OutputResolvers = Record<string, (value: any, isStable: boolean) => void>;