kurtosis-sdk 0.49.5

package/build/core/kurtosis_core_rpc_api_bindings/executable_module_service_grpc_pb.d.ts

@@ -0,0 +1,30 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+// package: module_api
+// file: executable_module_service.proto
+
+import * as executable_module_service_pb from "./executable_module_service_pb";
+import * as google_protobuf_empty_pb from "google-protobuf/google/protobuf/empty_pb";
+import * as grpc from "@grpc/grpc-js";
+
+interface IExecutableModuleServiceService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+  isAvailable: grpc.MethodDefinition<google_protobuf_empty_pb.Empty, google_protobuf_empty_pb.Empty>;
+  execute: grpc.MethodDefinition<executable_module_service_pb.ExecuteArgs, executable_module_service_pb.ExecuteResponse>;
+}
+
+export const ExecutableModuleServiceService: IExecutableModuleServiceService;
+
+export interface IExecutableModuleServiceServer extends grpc.UntypedServiceImplementation {
+  isAvailable: grpc.handleUnaryCall<google_protobuf_empty_pb.Empty, google_protobuf_empty_pb.Empty>;
+  execute: grpc.handleUnaryCall<executable_module_service_pb.ExecuteArgs, executable_module_service_pb.ExecuteResponse>;
+}
+
+export class ExecutableModuleServiceClient extends grpc.Client {
+  constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);
+  isAvailable(argument: google_protobuf_empty_pb.Empty, callback: grpc.requestCallback<google_protobuf_empty_pb.Empty>): grpc.ClientUnaryCall;
+  isAvailable(argument: google_protobuf_empty_pb.Empty, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<google_protobuf_empty_pb.Empty>): grpc.ClientUnaryCall;
+  isAvailable(argument: google_protobuf_empty_pb.Empty, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<google_protobuf_empty_pb.Empty>): grpc.ClientUnaryCall;
+  execute(argument: executable_module_service_pb.ExecuteArgs, callback: grpc.requestCallback<executable_module_service_pb.ExecuteResponse>): grpc.ClientUnaryCall;
+  execute(argument: executable_module_service_pb.ExecuteArgs, metadataOrOptions: grpc.Metadata | grpc.CallOptions | null, callback: grpc.requestCallback<executable_module_service_pb.ExecuteResponse>): grpc.ClientUnaryCall;
+  execute(argument: executable_module_service_pb.ExecuteArgs, metadata: grpc.Metadata | null, options: grpc.CallOptions | null, callback: grpc.requestCallback<executable_module_service_pb.ExecuteResponse>): grpc.ClientUnaryCall;
+}

package/build/core/kurtosis_core_rpc_api_bindings/executable_module_service_grpc_pb.js

@@ -0,0 +1,70 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+'use strict';
+var grpc = require('@grpc/grpc-js');
+var executable_module_service_pb = require('./executable_module_service_pb.js');
+var google_protobuf_empty_pb = require('google-protobuf/google/protobuf/empty_pb.js');
+
+function serialize_google_protobuf_Empty(arg) {
+  if (!(arg instanceof google_protobuf_empty_pb.Empty)) {
+    throw new Error('Expected argument of type google.protobuf.Empty');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_google_protobuf_Empty(buffer_arg) {
+  return google_protobuf_empty_pb.Empty.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_module_api_ExecuteArgs(arg) {
+  if (!(arg instanceof executable_module_service_pb.ExecuteArgs)) {
+    throw new Error('Expected argument of type module_api.ExecuteArgs');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_module_api_ExecuteArgs(buffer_arg) {
+  return executable_module_service_pb.ExecuteArgs.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_module_api_ExecuteResponse(arg) {
+  if (!(arg instanceof executable_module_service_pb.ExecuteResponse)) {
+    throw new Error('Expected argument of type module_api.ExecuteResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_module_api_ExecuteResponse(buffer_arg) {
+  return executable_module_service_pb.ExecuteResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+
+// A module that has an "execute" command
+var ExecutableModuleServiceService = exports.ExecutableModuleServiceService = {
+  // Returns true if the executable module is available
+isAvailable: {
+    path: '/module_api.ExecutableModuleService/IsAvailable',
+    requestStream: false,
+    responseStream: false,
+    requestType: google_protobuf_empty_pb.Empty,
+    responseType: google_protobuf_empty_pb.Empty,
+    requestSerialize: serialize_google_protobuf_Empty,
+    requestDeserialize: deserialize_google_protobuf_Empty,
+    responseSerialize: serialize_google_protobuf_Empty,
+    responseDeserialize: deserialize_google_protobuf_Empty,
+  },
+  // Runs the module's execute function
+execute: {
+    path: '/module_api.ExecutableModuleService/Execute',
+    requestStream: false,
+    responseStream: false,
+    requestType: executable_module_service_pb.ExecuteArgs,
+    responseType: executable_module_service_pb.ExecuteResponse,
+    requestSerialize: serialize_module_api_ExecuteArgs,
+    requestDeserialize: deserialize_module_api_ExecuteArgs,
+    responseSerialize: serialize_module_api_ExecuteResponse,
+    responseDeserialize: deserialize_module_api_ExecuteResponse,
+  },
+};
+
+exports.ExecutableModuleServiceClient = grpc.makeGenericClientConstructor(ExecutableModuleServiceService);

package/build/core/kurtosis_core_rpc_api_bindings/executable_module_service_grpc_web_pb.d.ts

@@ -0,0 +1,44 @@
+import * as grpcWeb from 'grpc-web';
+
+import * as google_protobuf_empty_pb from 'google-protobuf/google/protobuf/empty_pb';
+import * as executable_module_service_pb from './executable_module_service_pb';
+
+
+export class ExecutableModuleServiceClient {
+  constructor (hostname: string,
+               credentials?: null | { [index: string]: string; },
+               options?: null | { [index: string]: any; });
+
+  isAvailable(
+    request: google_protobuf_empty_pb.Empty,
+    metadata: grpcWeb.Metadata | undefined,
+    callback: (err: grpcWeb.RpcError,
+               response: google_protobuf_empty_pb.Empty) => void
+  ): grpcWeb.ClientReadableStream<google_protobuf_empty_pb.Empty>;
+
+  execute(
+    request: executable_module_service_pb.ExecuteArgs,
+    metadata: grpcWeb.Metadata | undefined,
+    callback: (err: grpcWeb.RpcError,
+               response: executable_module_service_pb.ExecuteResponse) => void
+  ): grpcWeb.ClientReadableStream<executable_module_service_pb.ExecuteResponse>;
+
+}
+
+export class ExecutableModuleServicePromiseClient {
+  constructor (hostname: string,
+               credentials?: null | { [index: string]: string; },
+               options?: null | { [index: string]: any; });
+
+  isAvailable(
+    request: google_protobuf_empty_pb.Empty,
+    metadata?: grpcWeb.Metadata
+  ): Promise<google_protobuf_empty_pb.Empty>;
+
+  execute(
+    request: executable_module_service_pb.ExecuteArgs,
+    metadata?: grpcWeb.Metadata
+  ): Promise<executable_module_service_pb.ExecuteResponse>;
+
+}
+

package/build/core/kurtosis_core_rpc_api_bindings/executable_module_service_grpc_web_pb.js

@@ -0,0 +1,198 @@
+/**
+ * @fileoverview gRPC-Web generated client stub for module_api
+ * @enhanceable
+ * @public
+ */
+
+// GENERATED CODE -- DO NOT EDIT!
+
+
+/* eslint-disable */
+// @ts-nocheck
+
+
+
+const grpc = {};
+grpc.web = require('grpc-web');
+
+
+var google_protobuf_empty_pb = require('google-protobuf/google/protobuf/empty_pb.js')
+const proto = {};
+proto.module_api = require('./executable_module_service_pb.js');
+
+/**
+ * @param {string} hostname
+ * @param {?Object} credentials
+ * @param {?grpc.web.ClientOptions} options
+ * @constructor
+ * @struct
+ * @final
+ */
+proto.module_api.ExecutableModuleServiceClient =
+    function(hostname, credentials, options) {
+  if (!options) options = {};
+  options.format = 'text';
+
+  /**
+   * @private @const {!grpc.web.GrpcWebClientBase} The client
+   */
+  this.client_ = new grpc.web.GrpcWebClientBase(options);
+
+  /**
+   * @private @const {string} The hostname
+   */
+  this.hostname_ = hostname;
+
+};
+
+
+/**
+ * @param {string} hostname
+ * @param {?Object} credentials
+ * @param {?grpc.web.ClientOptions} options
+ * @constructor
+ * @struct
+ * @final
+ */
+proto.module_api.ExecutableModuleServicePromiseClient =
+    function(hostname, credentials, options) {
+  if (!options) options = {};
+  options.format = 'text';
+
+  /**
+   * @private @const {!grpc.web.GrpcWebClientBase} The client
+   */
+  this.client_ = new grpc.web.GrpcWebClientBase(options);
+
+  /**
+   * @private @const {string} The hostname
+   */
+  this.hostname_ = hostname;
+
+};
+
+
+/**
+ * @const
+ * @type {!grpc.web.MethodDescriptor<
+ *   !proto.google.protobuf.Empty,
+ *   !proto.google.protobuf.Empty>}
+ */
+const methodDescriptor_ExecutableModuleService_IsAvailable = new grpc.web.MethodDescriptor(
+  '/module_api.ExecutableModuleService/IsAvailable',
+  grpc.web.MethodType.UNARY,
+  google_protobuf_empty_pb.Empty,
+  google_protobuf_empty_pb.Empty,
+  /**
+   * @param {!proto.google.protobuf.Empty} request
+   * @return {!Uint8Array}
+   */
+  function(request) {
+    return request.serializeBinary();
+  },
+  google_protobuf_empty_pb.Empty.deserializeBinary
+);
+
+
+/**
+ * @param {!proto.google.protobuf.Empty} request The
+ *     request proto
+ * @param {?Object<string, string>} metadata User defined
+ *     call metadata
+ * @param {function(?grpc.web.RpcError, ?proto.google.protobuf.Empty)}
+ *     callback The callback function(error, response)
+ * @return {!grpc.web.ClientReadableStream<!proto.google.protobuf.Empty>|undefined}
+ *     The XHR Node Readable Stream
+ */
+proto.module_api.ExecutableModuleServiceClient.prototype.isAvailable =
+    function(request, metadata, callback) {
+  return this.client_.rpcCall(this.hostname_ +
+      '/module_api.ExecutableModuleService/IsAvailable',
+      request,
+      metadata || {},
+      methodDescriptor_ExecutableModuleService_IsAvailable,
+      callback);
+};
+
+
+/**
+ * @param {!proto.google.protobuf.Empty} request The
+ *     request proto
+ * @param {?Object<string, string>=} metadata User defined
+ *     call metadata
+ * @return {!Promise<!proto.google.protobuf.Empty>}
+ *     Promise that resolves to the response
+ */
+proto.module_api.ExecutableModuleServicePromiseClient.prototype.isAvailable =
+    function(request, metadata) {
+  return this.client_.unaryCall(this.hostname_ +
+      '/module_api.ExecutableModuleService/IsAvailable',
+      request,
+      metadata || {},
+      methodDescriptor_ExecutableModuleService_IsAvailable);
+};
+
+
+/**
+ * @const
+ * @type {!grpc.web.MethodDescriptor<
+ *   !proto.module_api.ExecuteArgs,
+ *   !proto.module_api.ExecuteResponse>}
+ */
+const methodDescriptor_ExecutableModuleService_Execute = new grpc.web.MethodDescriptor(
+  '/module_api.ExecutableModuleService/Execute',
+  grpc.web.MethodType.UNARY,
+  proto.module_api.ExecuteArgs,
+  proto.module_api.ExecuteResponse,
+  /**
+   * @param {!proto.module_api.ExecuteArgs} request
+   * @return {!Uint8Array}
+   */
+  function(request) {
+    return request.serializeBinary();
+  },
+  proto.module_api.ExecuteResponse.deserializeBinary
+);
+
+
+/**
+ * @param {!proto.module_api.ExecuteArgs} request The
+ *     request proto
+ * @param {?Object<string, string>} metadata User defined
+ *     call metadata
+ * @param {function(?grpc.web.RpcError, ?proto.module_api.ExecuteResponse)}
+ *     callback The callback function(error, response)
+ * @return {!grpc.web.ClientReadableStream<!proto.module_api.ExecuteResponse>|undefined}
+ *     The XHR Node Readable Stream
+ */
+proto.module_api.ExecutableModuleServiceClient.prototype.execute =
+    function(request, metadata, callback) {
+  return this.client_.rpcCall(this.hostname_ +
+      '/module_api.ExecutableModuleService/Execute',
+      request,
+      metadata || {},
+      methodDescriptor_ExecutableModuleService_Execute,
+      callback);
+};
+
+
+/**
+ * @param {!proto.module_api.ExecuteArgs} request The
+ *     request proto
+ * @param {?Object<string, string>=} metadata User defined
+ *     call metadata
+ * @return {!Promise<!proto.module_api.ExecuteResponse>}
+ *     Promise that resolves to the response
+ */
+proto.module_api.ExecutableModuleServicePromiseClient.prototype.execute =
+    function(request, metadata) {
+  return this.client_.unaryCall(this.hostname_ +
+      '/module_api.ExecutableModuleService/Execute',
+      request,
+      metadata || {},
+      methodDescriptor_ExecutableModuleService_Execute);
+};
+
+
+module.exports = proto.module_api;
+

package/build/core/kurtosis_core_rpc_api_bindings/executable_module_service_pb.d.ts

@@ -0,0 +1,41 @@
+import * as jspb from 'google-protobuf'
+
+import * as google_protobuf_empty_pb from 'google-protobuf/google/protobuf/empty_pb';
+
+
+export class ExecuteArgs extends jspb.Message {
+  getParamsJson(): string;
+  setParamsJson(value: string): ExecuteArgs;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ExecuteArgs.AsObject;
+  static toObject(includeInstance: boolean, msg: ExecuteArgs): ExecuteArgs.AsObject;
+  static serializeBinaryToWriter(message: ExecuteArgs, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ExecuteArgs;
+  static deserializeBinaryFromReader(message: ExecuteArgs, reader: jspb.BinaryReader): ExecuteArgs;
+}
+
+export namespace ExecuteArgs {
+  export type AsObject = {
+    paramsJson: string,
+  }
+}
+
+export class ExecuteResponse extends jspb.Message {
+  getResponseJson(): string;
+  setResponseJson(value: string): ExecuteResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ExecuteResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: ExecuteResponse): ExecuteResponse.AsObject;
+  static serializeBinaryToWriter(message: ExecuteResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ExecuteResponse;
+  static deserializeBinaryFromReader(message: ExecuteResponse, reader: jspb.BinaryReader): ExecuteResponse;
+}
+
+export namespace ExecuteResponse {
+  export type AsObject = {
+    responseJson: string,
+  }
+}
+