github.com/pulumi/pulumi/sdk/v3@v3.108.1/nodejs/proto/language_pb.d.ts (about)

     1  // package: pulumirpc
     2  // file: pulumi/language.proto
     3  
     4  /* tslint:disable */
     5  /* eslint-disable */
     6  
     7  import * as jspb from "google-protobuf";
     8  import * as pulumi_codegen_hcl_pb from "./codegen/hcl_pb";
     9  import * as pulumi_plugin_pb from "./plugin_pb";
    10  import * as google_protobuf_empty_pb from "google-protobuf/google/protobuf/empty_pb";
    11  import * as google_protobuf_struct_pb from "google-protobuf/google/protobuf/struct_pb";
    12  
    13  export class ProgramInfo extends jspb.Message { 
    14      getRootDirectory(): string;
    15      setRootDirectory(value: string): ProgramInfo;
    16      getProgramDirectory(): string;
    17      setProgramDirectory(value: string): ProgramInfo;
    18      getEntryPoint(): string;
    19      setEntryPoint(value: string): ProgramInfo;
    20  
    21      hasOptions(): boolean;
    22      clearOptions(): void;
    23      getOptions(): google_protobuf_struct_pb.Struct | undefined;
    24      setOptions(value?: google_protobuf_struct_pb.Struct): ProgramInfo;
    25  
    26      serializeBinary(): Uint8Array;
    27      toObject(includeInstance?: boolean): ProgramInfo.AsObject;
    28      static toObject(includeInstance: boolean, msg: ProgramInfo): ProgramInfo.AsObject;
    29      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    30      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    31      static serializeBinaryToWriter(message: ProgramInfo, writer: jspb.BinaryWriter): void;
    32      static deserializeBinary(bytes: Uint8Array): ProgramInfo;
    33      static deserializeBinaryFromReader(message: ProgramInfo, reader: jspb.BinaryReader): ProgramInfo;
    34  }
    35  
    36  export namespace ProgramInfo {
    37      export type AsObject = {
    38          rootDirectory: string,
    39          programDirectory: string,
    40          entryPoint: string,
    41          options?: google_protobuf_struct_pb.Struct.AsObject,
    42      }
    43  }
    44  
    45  export class AboutResponse extends jspb.Message { 
    46      getExecutable(): string;
    47      setExecutable(value: string): AboutResponse;
    48      getVersion(): string;
    49      setVersion(value: string): AboutResponse;
    50  
    51      getMetadataMap(): jspb.Map<string, string>;
    52      clearMetadataMap(): void;
    53  
    54      serializeBinary(): Uint8Array;
    55      toObject(includeInstance?: boolean): AboutResponse.AsObject;
    56      static toObject(includeInstance: boolean, msg: AboutResponse): AboutResponse.AsObject;
    57      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    58      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    59      static serializeBinaryToWriter(message: AboutResponse, writer: jspb.BinaryWriter): void;
    60      static deserializeBinary(bytes: Uint8Array): AboutResponse;
    61      static deserializeBinaryFromReader(message: AboutResponse, reader: jspb.BinaryReader): AboutResponse;
    62  }
    63  
    64  export namespace AboutResponse {
    65      export type AsObject = {
    66          executable: string,
    67          version: string,
    68  
    69          metadataMap: Array<[string, string]>,
    70      }
    71  }
    72  
    73  export class GetProgramDependenciesRequest extends jspb.Message { 
    74      getProject(): string;
    75      setProject(value: string): GetProgramDependenciesRequest;
    76      getPwd(): string;
    77      setPwd(value: string): GetProgramDependenciesRequest;
    78      getProgram(): string;
    79      setProgram(value: string): GetProgramDependenciesRequest;
    80      getTransitivedependencies(): boolean;
    81      setTransitivedependencies(value: boolean): GetProgramDependenciesRequest;
    82  
    83      hasInfo(): boolean;
    84      clearInfo(): void;
    85      getInfo(): ProgramInfo | undefined;
    86      setInfo(value?: ProgramInfo): GetProgramDependenciesRequest;
    87  
    88      serializeBinary(): Uint8Array;
    89      toObject(includeInstance?: boolean): GetProgramDependenciesRequest.AsObject;
    90      static toObject(includeInstance: boolean, msg: GetProgramDependenciesRequest): GetProgramDependenciesRequest.AsObject;
    91      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    92      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    93      static serializeBinaryToWriter(message: GetProgramDependenciesRequest, writer: jspb.BinaryWriter): void;
    94      static deserializeBinary(bytes: Uint8Array): GetProgramDependenciesRequest;
    95      static deserializeBinaryFromReader(message: GetProgramDependenciesRequest, reader: jspb.BinaryReader): GetProgramDependenciesRequest;
    96  }
    97  
    98  export namespace GetProgramDependenciesRequest {
    99      export type AsObject = {
   100          project: string,
   101          pwd: string,
   102          program: string,
   103          transitivedependencies: boolean,
   104          info?: ProgramInfo.AsObject,
   105      }
   106  }
   107  
   108  export class DependencyInfo extends jspb.Message { 
   109      getName(): string;
   110      setName(value: string): DependencyInfo;
   111      getVersion(): string;
   112      setVersion(value: string): DependencyInfo;
   113  
   114      serializeBinary(): Uint8Array;
   115      toObject(includeInstance?: boolean): DependencyInfo.AsObject;
   116      static toObject(includeInstance: boolean, msg: DependencyInfo): DependencyInfo.AsObject;
   117      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   118      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   119      static serializeBinaryToWriter(message: DependencyInfo, writer: jspb.BinaryWriter): void;
   120      static deserializeBinary(bytes: Uint8Array): DependencyInfo;
   121      static deserializeBinaryFromReader(message: DependencyInfo, reader: jspb.BinaryReader): DependencyInfo;
   122  }
   123  
   124  export namespace DependencyInfo {
   125      export type AsObject = {
   126          name: string,
   127          version: string,
   128      }
   129  }
   130  
   131  export class GetProgramDependenciesResponse extends jspb.Message { 
   132      clearDependenciesList(): void;
   133      getDependenciesList(): Array<DependencyInfo>;
   134      setDependenciesList(value: Array<DependencyInfo>): GetProgramDependenciesResponse;
   135      addDependencies(value?: DependencyInfo, index?: number): DependencyInfo;
   136  
   137      serializeBinary(): Uint8Array;
   138      toObject(includeInstance?: boolean): GetProgramDependenciesResponse.AsObject;
   139      static toObject(includeInstance: boolean, msg: GetProgramDependenciesResponse): GetProgramDependenciesResponse.AsObject;
   140      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   141      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   142      static serializeBinaryToWriter(message: GetProgramDependenciesResponse, writer: jspb.BinaryWriter): void;
   143      static deserializeBinary(bytes: Uint8Array): GetProgramDependenciesResponse;
   144      static deserializeBinaryFromReader(message: GetProgramDependenciesResponse, reader: jspb.BinaryReader): GetProgramDependenciesResponse;
   145  }
   146  
   147  export namespace GetProgramDependenciesResponse {
   148      export type AsObject = {
   149          dependenciesList: Array<DependencyInfo.AsObject>,
   150      }
   151  }
   152  
   153  export class GetRequiredPluginsRequest extends jspb.Message { 
   154      getProject(): string;
   155      setProject(value: string): GetRequiredPluginsRequest;
   156      getPwd(): string;
   157      setPwd(value: string): GetRequiredPluginsRequest;
   158      getProgram(): string;
   159      setProgram(value: string): GetRequiredPluginsRequest;
   160  
   161      hasInfo(): boolean;
   162      clearInfo(): void;
   163      getInfo(): ProgramInfo | undefined;
   164      setInfo(value?: ProgramInfo): GetRequiredPluginsRequest;
   165  
   166      serializeBinary(): Uint8Array;
   167      toObject(includeInstance?: boolean): GetRequiredPluginsRequest.AsObject;
   168      static toObject(includeInstance: boolean, msg: GetRequiredPluginsRequest): GetRequiredPluginsRequest.AsObject;
   169      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   170      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   171      static serializeBinaryToWriter(message: GetRequiredPluginsRequest, writer: jspb.BinaryWriter): void;
   172      static deserializeBinary(bytes: Uint8Array): GetRequiredPluginsRequest;
   173      static deserializeBinaryFromReader(message: GetRequiredPluginsRequest, reader: jspb.BinaryReader): GetRequiredPluginsRequest;
   174  }
   175  
   176  export namespace GetRequiredPluginsRequest {
   177      export type AsObject = {
   178          project: string,
   179          pwd: string,
   180          program: string,
   181          info?: ProgramInfo.AsObject,
   182      }
   183  }
   184  
   185  export class GetRequiredPluginsResponse extends jspb.Message { 
   186      clearPluginsList(): void;
   187      getPluginsList(): Array<pulumi_plugin_pb.PluginDependency>;
   188      setPluginsList(value: Array<pulumi_plugin_pb.PluginDependency>): GetRequiredPluginsResponse;
   189      addPlugins(value?: pulumi_plugin_pb.PluginDependency, index?: number): pulumi_plugin_pb.PluginDependency;
   190  
   191      serializeBinary(): Uint8Array;
   192      toObject(includeInstance?: boolean): GetRequiredPluginsResponse.AsObject;
   193      static toObject(includeInstance: boolean, msg: GetRequiredPluginsResponse): GetRequiredPluginsResponse.AsObject;
   194      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   195      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   196      static serializeBinaryToWriter(message: GetRequiredPluginsResponse, writer: jspb.BinaryWriter): void;
   197      static deserializeBinary(bytes: Uint8Array): GetRequiredPluginsResponse;
   198      static deserializeBinaryFromReader(message: GetRequiredPluginsResponse, reader: jspb.BinaryReader): GetRequiredPluginsResponse;
   199  }
   200  
   201  export namespace GetRequiredPluginsResponse {
   202      export type AsObject = {
   203          pluginsList: Array<pulumi_plugin_pb.PluginDependency.AsObject>,
   204      }
   205  }
   206  
   207  export class RunRequest extends jspb.Message { 
   208      getProject(): string;
   209      setProject(value: string): RunRequest;
   210      getStack(): string;
   211      setStack(value: string): RunRequest;
   212      getPwd(): string;
   213      setPwd(value: string): RunRequest;
   214      getProgram(): string;
   215      setProgram(value: string): RunRequest;
   216      clearArgsList(): void;
   217      getArgsList(): Array<string>;
   218      setArgsList(value: Array<string>): RunRequest;
   219      addArgs(value: string, index?: number): string;
   220  
   221      getConfigMap(): jspb.Map<string, string>;
   222      clearConfigMap(): void;
   223      getDryrun(): boolean;
   224      setDryrun(value: boolean): RunRequest;
   225      getParallel(): number;
   226      setParallel(value: number): RunRequest;
   227      getMonitorAddress(): string;
   228      setMonitorAddress(value: string): RunRequest;
   229      getQuerymode(): boolean;
   230      setQuerymode(value: boolean): RunRequest;
   231      clearConfigsecretkeysList(): void;
   232      getConfigsecretkeysList(): Array<string>;
   233      setConfigsecretkeysList(value: Array<string>): RunRequest;
   234      addConfigsecretkeys(value: string, index?: number): string;
   235      getOrganization(): string;
   236      setOrganization(value: string): RunRequest;
   237  
   238      hasConfigpropertymap(): boolean;
   239      clearConfigpropertymap(): void;
   240      getConfigpropertymap(): google_protobuf_struct_pb.Struct | undefined;
   241      setConfigpropertymap(value?: google_protobuf_struct_pb.Struct): RunRequest;
   242  
   243      hasInfo(): boolean;
   244      clearInfo(): void;
   245      getInfo(): ProgramInfo | undefined;
   246      setInfo(value?: ProgramInfo): RunRequest;
   247  
   248      serializeBinary(): Uint8Array;
   249      toObject(includeInstance?: boolean): RunRequest.AsObject;
   250      static toObject(includeInstance: boolean, msg: RunRequest): RunRequest.AsObject;
   251      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   252      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   253      static serializeBinaryToWriter(message: RunRequest, writer: jspb.BinaryWriter): void;
   254      static deserializeBinary(bytes: Uint8Array): RunRequest;
   255      static deserializeBinaryFromReader(message: RunRequest, reader: jspb.BinaryReader): RunRequest;
   256  }
   257  
   258  export namespace RunRequest {
   259      export type AsObject = {
   260          project: string,
   261          stack: string,
   262          pwd: string,
   263          program: string,
   264          argsList: Array<string>,
   265  
   266          configMap: Array<[string, string]>,
   267          dryrun: boolean,
   268          parallel: number,
   269          monitorAddress: string,
   270          querymode: boolean,
   271          configsecretkeysList: Array<string>,
   272          organization: string,
   273          configpropertymap?: google_protobuf_struct_pb.Struct.AsObject,
   274          info?: ProgramInfo.AsObject,
   275      }
   276  }
   277  
   278  export class RunResponse extends jspb.Message { 
   279      getError(): string;
   280      setError(value: string): RunResponse;
   281      getBail(): boolean;
   282      setBail(value: boolean): RunResponse;
   283  
   284      serializeBinary(): Uint8Array;
   285      toObject(includeInstance?: boolean): RunResponse.AsObject;
   286      static toObject(includeInstance: boolean, msg: RunResponse): RunResponse.AsObject;
   287      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   288      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   289      static serializeBinaryToWriter(message: RunResponse, writer: jspb.BinaryWriter): void;
   290      static deserializeBinary(bytes: Uint8Array): RunResponse;
   291      static deserializeBinaryFromReader(message: RunResponse, reader: jspb.BinaryReader): RunResponse;
   292  }
   293  
   294  export namespace RunResponse {
   295      export type AsObject = {
   296          error: string,
   297          bail: boolean,
   298      }
   299  }
   300  
   301  export class InstallDependenciesRequest extends jspb.Message { 
   302      getDirectory(): string;
   303      setDirectory(value: string): InstallDependenciesRequest;
   304      getIsTerminal(): boolean;
   305      setIsTerminal(value: boolean): InstallDependenciesRequest;
   306  
   307      hasInfo(): boolean;
   308      clearInfo(): void;
   309      getInfo(): ProgramInfo | undefined;
   310      setInfo(value?: ProgramInfo): InstallDependenciesRequest;
   311  
   312      serializeBinary(): Uint8Array;
   313      toObject(includeInstance?: boolean): InstallDependenciesRequest.AsObject;
   314      static toObject(includeInstance: boolean, msg: InstallDependenciesRequest): InstallDependenciesRequest.AsObject;
   315      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   316      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   317      static serializeBinaryToWriter(message: InstallDependenciesRequest, writer: jspb.BinaryWriter): void;
   318      static deserializeBinary(bytes: Uint8Array): InstallDependenciesRequest;
   319      static deserializeBinaryFromReader(message: InstallDependenciesRequest, reader: jspb.BinaryReader): InstallDependenciesRequest;
   320  }
   321  
   322  export namespace InstallDependenciesRequest {
   323      export type AsObject = {
   324          directory: string,
   325          isTerminal: boolean,
   326          info?: ProgramInfo.AsObject,
   327      }
   328  }
   329  
   330  export class InstallDependenciesResponse extends jspb.Message { 
   331      getStdout(): Uint8Array | string;
   332      getStdout_asU8(): Uint8Array;
   333      getStdout_asB64(): string;
   334      setStdout(value: Uint8Array | string): InstallDependenciesResponse;
   335      getStderr(): Uint8Array | string;
   336      getStderr_asU8(): Uint8Array;
   337      getStderr_asB64(): string;
   338      setStderr(value: Uint8Array | string): InstallDependenciesResponse;
   339  
   340      serializeBinary(): Uint8Array;
   341      toObject(includeInstance?: boolean): InstallDependenciesResponse.AsObject;
   342      static toObject(includeInstance: boolean, msg: InstallDependenciesResponse): InstallDependenciesResponse.AsObject;
   343      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   344      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   345      static serializeBinaryToWriter(message: InstallDependenciesResponse, writer: jspb.BinaryWriter): void;
   346      static deserializeBinary(bytes: Uint8Array): InstallDependenciesResponse;
   347      static deserializeBinaryFromReader(message: InstallDependenciesResponse, reader: jspb.BinaryReader): InstallDependenciesResponse;
   348  }
   349  
   350  export namespace InstallDependenciesResponse {
   351      export type AsObject = {
   352          stdout: Uint8Array | string,
   353          stderr: Uint8Array | string,
   354      }
   355  }
   356  
   357  export class RunPluginRequest extends jspb.Message { 
   358      getPwd(): string;
   359      setPwd(value: string): RunPluginRequest;
   360      getProgram(): string;
   361      setProgram(value: string): RunPluginRequest;
   362      clearArgsList(): void;
   363      getArgsList(): Array<string>;
   364      setArgsList(value: Array<string>): RunPluginRequest;
   365      addArgs(value: string, index?: number): string;
   366      clearEnvList(): void;
   367      getEnvList(): Array<string>;
   368      setEnvList(value: Array<string>): RunPluginRequest;
   369      addEnv(value: string, index?: number): string;
   370  
   371      hasInfo(): boolean;
   372      clearInfo(): void;
   373      getInfo(): ProgramInfo | undefined;
   374      setInfo(value?: ProgramInfo): RunPluginRequest;
   375  
   376      serializeBinary(): Uint8Array;
   377      toObject(includeInstance?: boolean): RunPluginRequest.AsObject;
   378      static toObject(includeInstance: boolean, msg: RunPluginRequest): RunPluginRequest.AsObject;
   379      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   380      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   381      static serializeBinaryToWriter(message: RunPluginRequest, writer: jspb.BinaryWriter): void;
   382      static deserializeBinary(bytes: Uint8Array): RunPluginRequest;
   383      static deserializeBinaryFromReader(message: RunPluginRequest, reader: jspb.BinaryReader): RunPluginRequest;
   384  }
   385  
   386  export namespace RunPluginRequest {
   387      export type AsObject = {
   388          pwd: string,
   389          program: string,
   390          argsList: Array<string>,
   391          envList: Array<string>,
   392          info?: ProgramInfo.AsObject,
   393      }
   394  }
   395  
   396  export class RunPluginResponse extends jspb.Message { 
   397  
   398      hasStdout(): boolean;
   399      clearStdout(): void;
   400      getStdout(): Uint8Array | string;
   401      getStdout_asU8(): Uint8Array;
   402      getStdout_asB64(): string;
   403      setStdout(value: Uint8Array | string): RunPluginResponse;
   404  
   405      hasStderr(): boolean;
   406      clearStderr(): void;
   407      getStderr(): Uint8Array | string;
   408      getStderr_asU8(): Uint8Array;
   409      getStderr_asB64(): string;
   410      setStderr(value: Uint8Array | string): RunPluginResponse;
   411  
   412      hasExitcode(): boolean;
   413      clearExitcode(): void;
   414      getExitcode(): number;
   415      setExitcode(value: number): RunPluginResponse;
   416  
   417      getOutputCase(): RunPluginResponse.OutputCase;
   418  
   419      serializeBinary(): Uint8Array;
   420      toObject(includeInstance?: boolean): RunPluginResponse.AsObject;
   421      static toObject(includeInstance: boolean, msg: RunPluginResponse): RunPluginResponse.AsObject;
   422      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   423      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   424      static serializeBinaryToWriter(message: RunPluginResponse, writer: jspb.BinaryWriter): void;
   425      static deserializeBinary(bytes: Uint8Array): RunPluginResponse;
   426      static deserializeBinaryFromReader(message: RunPluginResponse, reader: jspb.BinaryReader): RunPluginResponse;
   427  }
   428  
   429  export namespace RunPluginResponse {
   430      export type AsObject = {
   431          stdout: Uint8Array | string,
   432          stderr: Uint8Array | string,
   433          exitcode: number,
   434      }
   435  
   436      export enum OutputCase {
   437          OUTPUT_NOT_SET = 0,
   438          STDOUT = 1,
   439          STDERR = 2,
   440          EXITCODE = 3,
   441      }
   442  
   443  }
   444  
   445  export class GenerateProgramRequest extends jspb.Message { 
   446  
   447      getSourceMap(): jspb.Map<string, string>;
   448      clearSourceMap(): void;
   449      getLoaderTarget(): string;
   450      setLoaderTarget(value: string): GenerateProgramRequest;
   451  
   452      serializeBinary(): Uint8Array;
   453      toObject(includeInstance?: boolean): GenerateProgramRequest.AsObject;
   454      static toObject(includeInstance: boolean, msg: GenerateProgramRequest): GenerateProgramRequest.AsObject;
   455      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   456      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   457      static serializeBinaryToWriter(message: GenerateProgramRequest, writer: jspb.BinaryWriter): void;
   458      static deserializeBinary(bytes: Uint8Array): GenerateProgramRequest;
   459      static deserializeBinaryFromReader(message: GenerateProgramRequest, reader: jspb.BinaryReader): GenerateProgramRequest;
   460  }
   461  
   462  export namespace GenerateProgramRequest {
   463      export type AsObject = {
   464  
   465          sourceMap: Array<[string, string]>,
   466          loaderTarget: string,
   467      }
   468  }
   469  
   470  export class GenerateProgramResponse extends jspb.Message { 
   471      clearDiagnosticsList(): void;
   472      getDiagnosticsList(): Array<pulumi_codegen_hcl_pb.Diagnostic>;
   473      setDiagnosticsList(value: Array<pulumi_codegen_hcl_pb.Diagnostic>): GenerateProgramResponse;
   474      addDiagnostics(value?: pulumi_codegen_hcl_pb.Diagnostic, index?: number): pulumi_codegen_hcl_pb.Diagnostic;
   475  
   476      getSourceMap(): jspb.Map<string, Uint8Array | string>;
   477      clearSourceMap(): void;
   478  
   479      serializeBinary(): Uint8Array;
   480      toObject(includeInstance?: boolean): GenerateProgramResponse.AsObject;
   481      static toObject(includeInstance: boolean, msg: GenerateProgramResponse): GenerateProgramResponse.AsObject;
   482      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   483      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   484      static serializeBinaryToWriter(message: GenerateProgramResponse, writer: jspb.BinaryWriter): void;
   485      static deserializeBinary(bytes: Uint8Array): GenerateProgramResponse;
   486      static deserializeBinaryFromReader(message: GenerateProgramResponse, reader: jspb.BinaryReader): GenerateProgramResponse;
   487  }
   488  
   489  export namespace GenerateProgramResponse {
   490      export type AsObject = {
   491          diagnosticsList: Array<pulumi_codegen_hcl_pb.Diagnostic.AsObject>,
   492  
   493          sourceMap: Array<[string, Uint8Array | string]>,
   494      }
   495  }
   496  
   497  export class GenerateProjectRequest extends jspb.Message { 
   498      getSourceDirectory(): string;
   499      setSourceDirectory(value: string): GenerateProjectRequest;
   500      getTargetDirectory(): string;
   501      setTargetDirectory(value: string): GenerateProjectRequest;
   502      getProject(): string;
   503      setProject(value: string): GenerateProjectRequest;
   504      getStrict(): boolean;
   505      setStrict(value: boolean): GenerateProjectRequest;
   506      getLoaderTarget(): string;
   507      setLoaderTarget(value: string): GenerateProjectRequest;
   508  
   509      getLocalDependenciesMap(): jspb.Map<string, string>;
   510      clearLocalDependenciesMap(): void;
   511  
   512      serializeBinary(): Uint8Array;
   513      toObject(includeInstance?: boolean): GenerateProjectRequest.AsObject;
   514      static toObject(includeInstance: boolean, msg: GenerateProjectRequest): GenerateProjectRequest.AsObject;
   515      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   516      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   517      static serializeBinaryToWriter(message: GenerateProjectRequest, writer: jspb.BinaryWriter): void;
   518      static deserializeBinary(bytes: Uint8Array): GenerateProjectRequest;
   519      static deserializeBinaryFromReader(message: GenerateProjectRequest, reader: jspb.BinaryReader): GenerateProjectRequest;
   520  }
   521  
   522  export namespace GenerateProjectRequest {
   523      export type AsObject = {
   524          sourceDirectory: string,
   525          targetDirectory: string,
   526          project: string,
   527          strict: boolean,
   528          loaderTarget: string,
   529  
   530          localDependenciesMap: Array<[string, string]>,
   531      }
   532  }
   533  
   534  export class GenerateProjectResponse extends jspb.Message { 
   535      clearDiagnosticsList(): void;
   536      getDiagnosticsList(): Array<pulumi_codegen_hcl_pb.Diagnostic>;
   537      setDiagnosticsList(value: Array<pulumi_codegen_hcl_pb.Diagnostic>): GenerateProjectResponse;
   538      addDiagnostics(value?: pulumi_codegen_hcl_pb.Diagnostic, index?: number): pulumi_codegen_hcl_pb.Diagnostic;
   539  
   540      serializeBinary(): Uint8Array;
   541      toObject(includeInstance?: boolean): GenerateProjectResponse.AsObject;
   542      static toObject(includeInstance: boolean, msg: GenerateProjectResponse): GenerateProjectResponse.AsObject;
   543      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   544      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   545      static serializeBinaryToWriter(message: GenerateProjectResponse, writer: jspb.BinaryWriter): void;
   546      static deserializeBinary(bytes: Uint8Array): GenerateProjectResponse;
   547      static deserializeBinaryFromReader(message: GenerateProjectResponse, reader: jspb.BinaryReader): GenerateProjectResponse;
   548  }
   549  
   550  export namespace GenerateProjectResponse {
   551      export type AsObject = {
   552          diagnosticsList: Array<pulumi_codegen_hcl_pb.Diagnostic.AsObject>,
   553      }
   554  }
   555  
   556  export class GeneratePackageRequest extends jspb.Message { 
   557      getDirectory(): string;
   558      setDirectory(value: string): GeneratePackageRequest;
   559      getSchema(): string;
   560      setSchema(value: string): GeneratePackageRequest;
   561  
   562      getExtraFilesMap(): jspb.Map<string, Uint8Array | string>;
   563      clearExtraFilesMap(): void;
   564      getLoaderTarget(): string;
   565      setLoaderTarget(value: string): GeneratePackageRequest;
   566  
   567      serializeBinary(): Uint8Array;
   568      toObject(includeInstance?: boolean): GeneratePackageRequest.AsObject;
   569      static toObject(includeInstance: boolean, msg: GeneratePackageRequest): GeneratePackageRequest.AsObject;
   570      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   571      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   572      static serializeBinaryToWriter(message: GeneratePackageRequest, writer: jspb.BinaryWriter): void;
   573      static deserializeBinary(bytes: Uint8Array): GeneratePackageRequest;
   574      static deserializeBinaryFromReader(message: GeneratePackageRequest, reader: jspb.BinaryReader): GeneratePackageRequest;
   575  }
   576  
   577  export namespace GeneratePackageRequest {
   578      export type AsObject = {
   579          directory: string,
   580          schema: string,
   581  
   582          extraFilesMap: Array<[string, Uint8Array | string]>,
   583          loaderTarget: string,
   584      }
   585  }
   586  
   587  export class GeneratePackageResponse extends jspb.Message { 
   588      clearDiagnosticsList(): void;
   589      getDiagnosticsList(): Array<pulumi_codegen_hcl_pb.Diagnostic>;
   590      setDiagnosticsList(value: Array<pulumi_codegen_hcl_pb.Diagnostic>): GeneratePackageResponse;
   591      addDiagnostics(value?: pulumi_codegen_hcl_pb.Diagnostic, index?: number): pulumi_codegen_hcl_pb.Diagnostic;
   592  
   593      serializeBinary(): Uint8Array;
   594      toObject(includeInstance?: boolean): GeneratePackageResponse.AsObject;
   595      static toObject(includeInstance: boolean, msg: GeneratePackageResponse): GeneratePackageResponse.AsObject;
   596      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   597      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   598      static serializeBinaryToWriter(message: GeneratePackageResponse, writer: jspb.BinaryWriter): void;
   599      static deserializeBinary(bytes: Uint8Array): GeneratePackageResponse;
   600      static deserializeBinaryFromReader(message: GeneratePackageResponse, reader: jspb.BinaryReader): GeneratePackageResponse;
   601  }
   602  
   603  export namespace GeneratePackageResponse {
   604      export type AsObject = {
   605          diagnosticsList: Array<pulumi_codegen_hcl_pb.Diagnostic.AsObject>,
   606      }
   607  }
   608  
   609  export class PackRequest extends jspb.Message { 
   610      getPackageDirectory(): string;
   611      setPackageDirectory(value: string): PackRequest;
   612      getVersion(): string;
   613      setVersion(value: string): PackRequest;
   614      getDestinationDirectory(): string;
   615      setDestinationDirectory(value: string): PackRequest;
   616  
   617      serializeBinary(): Uint8Array;
   618      toObject(includeInstance?: boolean): PackRequest.AsObject;
   619      static toObject(includeInstance: boolean, msg: PackRequest): PackRequest.AsObject;
   620      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   621      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   622      static serializeBinaryToWriter(message: PackRequest, writer: jspb.BinaryWriter): void;
   623      static deserializeBinary(bytes: Uint8Array): PackRequest;
   624      static deserializeBinaryFromReader(message: PackRequest, reader: jspb.BinaryReader): PackRequest;
   625  }
   626  
   627  export namespace PackRequest {
   628      export type AsObject = {
   629          packageDirectory: string,
   630          version: string,
   631          destinationDirectory: string,
   632      }
   633  }
   634  
   635  export class PackResponse extends jspb.Message { 
   636      getArtifactPath(): string;
   637      setArtifactPath(value: string): PackResponse;
   638  
   639      serializeBinary(): Uint8Array;
   640      toObject(includeInstance?: boolean): PackResponse.AsObject;
   641      static toObject(includeInstance: boolean, msg: PackResponse): PackResponse.AsObject;
   642      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   643      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   644      static serializeBinaryToWriter(message: PackResponse, writer: jspb.BinaryWriter): void;
   645      static deserializeBinary(bytes: Uint8Array): PackResponse;
   646      static deserializeBinaryFromReader(message: PackResponse, reader: jspb.BinaryReader): PackResponse;
   647  }
   648  
   649  export namespace PackResponse {
   650      export type AsObject = {
   651          artifactPath: string,
   652      }
   653  }