@forwardimpact/librpc 0.1.105 → 0.1.107

package/src/generated/services/map/client.js

@@ -0,0 +1,104 @@
+/* eslint no-unused-vars: "off" */
+
+import { Client } from "@forwardimpact/librpc/client.js";
+import { createAuth, createGrpc } from "@forwardimpact/librpc/base.js";
+import { createObserver } from "@forwardimpact/libtelemetry";
+import { map, tool } from "@forwardimpact/libtype";
+
+/**
+ * Typed client for the Map gRPC service.
+ * Extends the `Client` class for shared gRPC client functionality.
+ */
+export class MapClient extends Client {
+  /**
+   * Creates a new Map client instance
+   * @param {object} config - Service configuration
+   * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime - Injected runtime bag (required; the default auth factory reads SERVICE_SECRET from it)
+   * @param {import("@forwardimpact/libtelemetry").Logger} [logger] - Optional logger instance
+   * @param {import("@forwardimpact/libtelemetry").Tracer} [tracer] - Optional tracer for distributed tracing
+   * @param {Function} [authFn] - Optional authentication function
+   */
+  constructor(config, runtime, logger = null, tracer = null, authFn = createAuth) {
+    super(config, runtime, logger, tracer, createObserver, createGrpc, authFn);
+  }
+
+  /**
+   * Call the `GetUnscoredArtifacts` RPC with request/response type conversion.
+   * @param { map.GetUnscoredArtifactsRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async GetUnscoredArtifacts(req) {
+    // Type validation
+    if (!(req instanceof map.GetUnscoredArtifactsRequest)) {
+      throw new TypeError(
+        `GetUnscoredArtifacts: Expected parameter to be instanceof map.GetUnscoredArtifactsRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = map.GetUnscoredArtifactsRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("GetUnscoredArtifacts", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `GetArtifact` RPC with request/response type conversion.
+   * @param { map.GetArtifactRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async GetArtifact(req) {
+    // Type validation
+    if (!(req instanceof map.GetArtifactRequest)) {
+      throw new TypeError(
+        `GetArtifact: Expected parameter to be instanceof map.GetArtifactRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = map.GetArtifactRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("GetArtifact", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `WriteEvidence` RPC with request/response type conversion.
+   * @param { map.WriteEvidenceRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async WriteEvidence(req) {
+    // Type validation
+    if (!(req instanceof map.WriteEvidenceRequest)) {
+      throw new TypeError(
+        `WriteEvidence: Expected parameter to be instanceof map.WriteEvidenceRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = map.WriteEvidenceRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("WriteEvidence", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `GetPerson` RPC with request/response type conversion.
+   * @param { map.GetPersonRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async GetPerson(req) {
+    // Type validation
+    if (!(req instanceof map.GetPersonRequest)) {
+      throw new TypeError(
+        `GetPerson: Expected parameter to be instanceof map.GetPersonRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = map.GetPersonRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("GetPerson", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+}

package/src/generated/services/map/service.js

@@ -0,0 +1,100 @@
+/* eslint no-unused-vars: "off" */
+
+import { map, tool } from "@forwardimpact/libtype";
+
+/**
+ * Base class for Map service implementation
+ */
+export class MapBase {
+  config;
+
+  /**
+   * Creates a new Map service instance
+   * @param {object} config - Service configuration
+   */
+  constructor(config) {
+    if (!config) throw new Error("config is required");
+    this.config = config;
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { map.GetUnscoredArtifactsRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async GetUnscoredArtifacts(req) {
+    throw new Error("GetUnscoredArtifacts not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { map.GetArtifactRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async GetArtifact(req) {
+    throw new Error("GetArtifact not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { map.WriteEvidenceRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async WriteEvidence(req) {
+    throw new Error("WriteEvidence not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { map.GetPersonRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async GetPerson(req) {
+    throw new Error("GetPerson not implemented");
+  }
+
+  /**
+   * Creates gRPC handlers for this service instance
+   * @returns { object } Map of method names to handler functions
+   */
+  getHandlers() {
+    return {
+      GetUnscoredArtifacts: async (call) => {
+        // Validate and convert request
+        const error = map.GetUnscoredArtifactsRequest.verify(call.request);
+        if (error) throw new Error(`GetUnscoredArtifacts: ${error}`);
+        const req = map.GetUnscoredArtifactsRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.GetUnscoredArtifacts(req);
+      },
+      GetArtifact: async (call) => {
+        // Validate and convert request
+        const error = map.GetArtifactRequest.verify(call.request);
+        if (error) throw new Error(`GetArtifact: ${error}`);
+        const req = map.GetArtifactRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.GetArtifact(req);
+      },
+      WriteEvidence: async (call) => {
+        // Validate and convert request
+        const error = map.WriteEvidenceRequest.verify(call.request);
+        if (error) throw new Error(`WriteEvidence: ${error}`);
+        const req = map.WriteEvidenceRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.WriteEvidence(req);
+      },
+      GetPerson: async (call) => {
+        // Validate and convert request
+        const error = map.GetPersonRequest.verify(call.request);
+        if (error) throw new Error(`GetPerson: ${error}`);
+        const req = map.GetPersonRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.GetPerson(req);
+      },
+    };
+  }
+}

package/src/generated/services/pathway/client.js

@@ -0,0 +1,164 @@
+/* eslint no-unused-vars: "off" */
+
+import { Client } from "@forwardimpact/librpc/client.js";
+import { createAuth, createGrpc } from "@forwardimpact/librpc/base.js";
+import { createObserver } from "@forwardimpact/libtelemetry";
+import { pathway, tool } from "@forwardimpact/libtype";
+
+/**
+ * Typed client for the Pathway gRPC service.
+ * Extends the `Client` class for shared gRPC client functionality.
+ */
+export class PathwayClient extends Client {
+  /**
+   * Creates a new Pathway client instance
+   * @param {object} config - Service configuration
+   * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime - Injected runtime bag (required; the default auth factory reads SERVICE_SECRET from it)
+   * @param {import("@forwardimpact/libtelemetry").Logger} [logger] - Optional logger instance
+   * @param {import("@forwardimpact/libtelemetry").Tracer} [tracer] - Optional tracer for distributed tracing
+   * @param {Function} [authFn] - Optional authentication function
+   */
+  constructor(config, runtime, logger = null, tracer = null, authFn = createAuth) {
+    super(config, runtime, logger, tracer, createObserver, createGrpc, authFn);
+  }
+
+  /**
+   * Call the `ListJobs` RPC with request/response type conversion.
+   * @param { pathway.ListJobsRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async ListJobs(req) {
+    // Type validation
+    if (!(req instanceof pathway.ListJobsRequest)) {
+      throw new TypeError(
+        `ListJobs: Expected parameter to be instanceof pathway.ListJobsRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = pathway.ListJobsRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("ListJobs", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `DescribeJob` RPC with request/response type conversion.
+   * @param { pathway.DescribeJobRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async DescribeJob(req) {
+    // Type validation
+    if (!(req instanceof pathway.DescribeJobRequest)) {
+      throw new TypeError(
+        `DescribeJob: Expected parameter to be instanceof pathway.DescribeJobRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = pathway.DescribeJobRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("DescribeJob", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `ListAgentProfiles` RPC with request/response type conversion.
+   * @param { pathway.ListAgentProfilesRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async ListAgentProfiles(req) {
+    // Type validation
+    if (!(req instanceof pathway.ListAgentProfilesRequest)) {
+      throw new TypeError(
+        `ListAgentProfiles: Expected parameter to be instanceof pathway.ListAgentProfilesRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = pathway.ListAgentProfilesRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("ListAgentProfiles", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `DescribeAgentProfile` RPC with request/response type conversion.
+   * @param { pathway.DescribeAgentProfileRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async DescribeAgentProfile(req) {
+    // Type validation
+    if (!(req instanceof pathway.DescribeAgentProfileRequest)) {
+      throw new TypeError(
+        `DescribeAgentProfile: Expected parameter to be instanceof pathway.DescribeAgentProfileRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = pathway.DescribeAgentProfileRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("DescribeAgentProfile", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `DescribeProgression` RPC with request/response type conversion.
+   * @param { pathway.DescribeProgressionRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async DescribeProgression(req) {
+    // Type validation
+    if (!(req instanceof pathway.DescribeProgressionRequest)) {
+      throw new TypeError(
+        `DescribeProgression: Expected parameter to be instanceof pathway.DescribeProgressionRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = pathway.DescribeProgressionRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("DescribeProgression", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `ListJobSoftware` RPC with request/response type conversion.
+   * @param { pathway.ListJobSoftwareRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async ListJobSoftware(req) {
+    // Type validation
+    if (!(req instanceof pathway.ListJobSoftwareRequest)) {
+      throw new TypeError(
+        `ListJobSoftware: Expected parameter to be instanceof pathway.ListJobSoftwareRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = pathway.ListJobSoftwareRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("ListJobSoftware", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+
+  /**
+   * Call the `GetMarkersForProfile` RPC with request/response type conversion.
+   * @param { pathway.GetMarkersForProfileRequest } req - Typed request message.
+   * @returns { Promise<tool.ToolCallResult> } Typed response message.
+   */
+  async GetMarkersForProfile(req) {
+    // Type validation
+    if (!(req instanceof pathway.GetMarkersForProfileRequest)) {
+      throw new TypeError(
+        `GetMarkersForProfile: Expected parameter to be instanceof pathway.GetMarkersForProfileRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = pathway.GetMarkersForProfileRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("GetMarkersForProfile", request, (res) => tool.ToolCallResult.fromObject(res));
+  }
+}

package/src/generated/services/pathway/service.js

@@ -0,0 +1,154 @@
+/* eslint no-unused-vars: "off" */
+
+import { pathway, tool } from "@forwardimpact/libtype";
+
+/**
+ * Base class for Pathway service implementation
+ */
+export class PathwayBase {
+  config;
+
+  /**
+   * Creates a new Pathway service instance
+   * @param {object} config - Service configuration
+   */
+  constructor(config) {
+    if (!config) throw new Error("config is required");
+    this.config = config;
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { pathway.ListJobsRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async ListJobs(req) {
+    throw new Error("ListJobs not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { pathway.DescribeJobRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async DescribeJob(req) {
+    throw new Error("DescribeJob not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { pathway.ListAgentProfilesRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async ListAgentProfiles(req) {
+    throw new Error("ListAgentProfiles not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { pathway.DescribeAgentProfileRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async DescribeAgentProfile(req) {
+    throw new Error("DescribeAgentProfile not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { pathway.DescribeProgressionRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async DescribeProgression(req) {
+    throw new Error("DescribeProgression not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { pathway.ListJobSoftwareRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async ListJobSoftware(req) {
+    throw new Error("ListJobSoftware not implemented");
+  }
+
+  /**
+   * Must be implemented by subclass
+   * @param { pathway.GetMarkersForProfileRequest } req - Request parameters
+   * @returns { Promise<tool.ToolCallResult> } Response object
+   */
+  async GetMarkersForProfile(req) {
+    throw new Error("GetMarkersForProfile not implemented");
+  }
+
+  /**
+   * Creates gRPC handlers for this service instance
+   * @returns { object } Map of method names to handler functions
+   */
+  getHandlers() {
+    return {
+      ListJobs: async (call) => {
+        // Validate and convert request
+        const error = pathway.ListJobsRequest.verify(call.request);
+        if (error) throw new Error(`ListJobs: ${error}`);
+        const req = pathway.ListJobsRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.ListJobs(req);
+      },
+      DescribeJob: async (call) => {
+        // Validate and convert request
+        const error = pathway.DescribeJobRequest.verify(call.request);
+        if (error) throw new Error(`DescribeJob: ${error}`);
+        const req = pathway.DescribeJobRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.DescribeJob(req);
+      },
+      ListAgentProfiles: async (call) => {
+        // Validate and convert request
+        const error = pathway.ListAgentProfilesRequest.verify(call.request);
+        if (error) throw new Error(`ListAgentProfiles: ${error}`);
+        const req = pathway.ListAgentProfilesRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.ListAgentProfiles(req);
+      },
+      DescribeAgentProfile: async (call) => {
+        // Validate and convert request
+        const error = pathway.DescribeAgentProfileRequest.verify(call.request);
+        if (error) throw new Error(`DescribeAgentProfile: ${error}`);
+        const req = pathway.DescribeAgentProfileRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.DescribeAgentProfile(req);
+      },
+      DescribeProgression: async (call) => {
+        // Validate and convert request
+        const error = pathway.DescribeProgressionRequest.verify(call.request);
+        if (error) throw new Error(`DescribeProgression: ${error}`);
+        const req = pathway.DescribeProgressionRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.DescribeProgression(req);
+      },
+      ListJobSoftware: async (call) => {
+        // Validate and convert request
+        const error = pathway.ListJobSoftwareRequest.verify(call.request);
+        if (error) throw new Error(`ListJobSoftware: ${error}`);
+        const req = pathway.ListJobSoftwareRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.ListJobSoftware(req);
+      },
+      GetMarkersForProfile: async (call) => {
+        // Validate and convert request
+        const error = pathway.GetMarkersForProfileRequest.verify(call.request);
+        if (error) throw new Error(`GetMarkersForProfile: ${error}`);
+        const req = pathway.GetMarkersForProfileRequest.fromObject(call.request);
+        
+        // Call implementation
+        return await this.GetMarkersForProfile(req);
+      },
+    };
+  }
+}

package/src/generated/services/tenancy/client.js

@@ -0,0 +1,164 @@
+/* eslint no-unused-vars: "off" */
+
+import { Client } from "@forwardimpact/librpc/client.js";
+import { createAuth, createGrpc } from "@forwardimpact/librpc/base.js";
+import { createObserver } from "@forwardimpact/libtelemetry";
+import { tenancy } from "@forwardimpact/libtype";
+
+/**
+ * Typed client for the Tenancy gRPC service.
+ * Extends the `Client` class for shared gRPC client functionality.
+ */
+export class TenancyClient extends Client {
+  /**
+   * Creates a new Tenancy client instance
+   * @param {object} config - Service configuration
+   * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime - Injected runtime bag (required; the default auth factory reads SERVICE_SECRET from it)
+   * @param {import("@forwardimpact/libtelemetry").Logger} [logger] - Optional logger instance
+   * @param {import("@forwardimpact/libtelemetry").Tracer} [tracer] - Optional tracer for distributed tracing
+   * @param {Function} [authFn] - Optional authentication function
+   */
+  constructor(config, runtime, logger = null, tracer = null, authFn = createAuth) {
+    super(config, runtime, logger, tracer, createObserver, createGrpc, authFn);
+  }
+
+  /**
+   * Call the `ResolveByChannelKey` RPC with request/response type conversion.
+   * @param { tenancy.ChannelTenantKey } req - Typed request message.
+   * @returns { Promise<tenancy.Tenant> } Typed response message.
+   */
+  async ResolveByChannelKey(req) {
+    // Type validation
+    if (!(req instanceof tenancy.ChannelTenantKey)) {
+      throw new TypeError(
+        `ResolveByChannelKey: Expected parameter to be instanceof tenancy.ChannelTenantKey`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = tenancy.ChannelTenantKey.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("ResolveByChannelKey", request, (res) => tenancy.Tenant.fromObject(res));
+  }
+
+  /**
+   * Call the `ResolveByRepo` RPC with request/response type conversion.
+   * @param { tenancy.RepoKey } req - Typed request message.
+   * @returns { Promise<tenancy.Tenant> } Typed response message.
+   */
+  async ResolveByRepo(req) {
+    // Type validation
+    if (!(req instanceof tenancy.RepoKey)) {
+      throw new TypeError(
+        `ResolveByRepo: Expected parameter to be instanceof tenancy.RepoKey`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = tenancy.RepoKey.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("ResolveByRepo", request, (res) => tenancy.Tenant.fromObject(res));
+  }
+
+  /**
+   * Call the `ResolveByTenantId` RPC with request/response type conversion.
+   * @param { tenancy.TenantIdKey } req - Typed request message.
+   * @returns { Promise<tenancy.Tenant> } Typed response message.
+   */
+  async ResolveByTenantId(req) {
+    // Type validation
+    if (!(req instanceof tenancy.TenantIdKey)) {
+      throw new TypeError(
+        `ResolveByTenantId: Expected parameter to be instanceof tenancy.TenantIdKey`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = tenancy.TenantIdKey.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("ResolveByTenantId", request, (res) => tenancy.Tenant.fromObject(res));
+  }
+
+  /**
+   * Call the `UpsertByChannelKey` RPC with request/response type conversion.
+   * @param { tenancy.UpsertChannelKeyRequest } req - Typed request message.
+   * @returns { Promise<tenancy.Tenant> } Typed response message.
+   */
+  async UpsertByChannelKey(req) {
+    // Type validation
+    if (!(req instanceof tenancy.UpsertChannelKeyRequest)) {
+      throw new TypeError(
+        `UpsertByChannelKey: Expected parameter to be instanceof tenancy.UpsertChannelKeyRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = tenancy.UpsertChannelKeyRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("UpsertByChannelKey", request, (res) => tenancy.Tenant.fromObject(res));
+  }
+
+  /**
+   * Call the `UpsertByPair` RPC with request/response type conversion.
+   * @param { tenancy.UpsertPairRequest } req - Typed request message.
+   * @returns { Promise<tenancy.Tenant> } Typed response message.
+   */
+  async UpsertByPair(req) {
+    // Type validation
+    if (!(req instanceof tenancy.UpsertPairRequest)) {
+      throw new TypeError(
+        `UpsertByPair: Expected parameter to be instanceof tenancy.UpsertPairRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = tenancy.UpsertPairRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("UpsertByPair", request, (res) => tenancy.Tenant.fromObject(res));
+  }
+
+  /**
+   * Call the `SetState` RPC with request/response type conversion.
+   * @param { tenancy.SetStateRequest } req - Typed request message.
+   * @returns { Promise<tenancy.Tenant> } Typed response message.
+   */
+  async SetState(req) {
+    // Type validation
+    if (!(req instanceof tenancy.SetStateRequest)) {
+      throw new TypeError(
+        `SetState: Expected parameter to be instanceof tenancy.SetStateRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = tenancy.SetStateRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("SetState", request, (res) => tenancy.Tenant.fromObject(res));
+  }
+
+  /**
+   * Call the `SetRepo` RPC with request/response type conversion.
+   * @param { tenancy.SetRepoRequest } req - Typed request message.
+   * @returns { Promise<tenancy.Tenant> } Typed response message.
+   */
+  async SetRepo(req) {
+    // Type validation
+    if (!(req instanceof tenancy.SetRepoRequest)) {
+      throw new TypeError(
+        `SetRepo: Expected parameter to be instanceof tenancy.SetRepoRequest`,
+      );
+    }
+    
+    // Convert to plain object
+    const request = tenancy.SetRepoRequest.toObject(req);
+    
+    // Make gRPC call (tracing handled by base Client class)
+    return this.callUnary("SetRepo", request, (res) => tenancy.Tenant.fromObject(res));
+  }
+}