Variable PUBLIC_METHODSConst

Type Declaration

• Readonlyagent: {
      cancelTurn: {
          service: "Agent";
          method: "CancelTurn";
          grpcPath: "/gestalt.provider.v1.Agent/CancelTurn";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/agent/sessions/{session_id}/turns/{turn_id}:cancel";
              body: "*";
              pathFields: readonly [
                  { name: "session_id"; jsonName: "sessionId" },
                  { name: "turn_id"; jsonName: "turnId" },
              ];
              queryFields: readonly [];
          };
      };
      createSession: {
          service: "Agent";
          method: "CreateSession";
          grpcPath: "/gestalt.provider.v1.Agent/CreateSession";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/agent/sessions";
              body: "*";
              pathFields: readonly [];
              queryFields: readonly [];
          };
      };
      createTurn: {
          service: "Agent";
          method: "CreateTurn";
          grpcPath: "/gestalt.provider.v1.Agent/CreateTurn";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/agent/sessions/{session_id}/turns";
              body: "*";
              pathFields: readonly [{ name: "session_id"; jsonName: "sessionId" }];
              queryFields: readonly [];
          };
      };
      getSession: {
          service: "Agent";
          method: "GetSession";
          grpcPath: "/gestalt.provider.v1.Agent/GetSession";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/agent/sessions/{session_id}";
              body: "";
              pathFields: readonly [{ name: "session_id"; jsonName: "sessionId" }];
              queryFields: readonly [
                  { name: "provider_name"; jsonName: "providerName" },
              ];
          };
      };
      getTurn: {
          service: "Agent";
          method: "GetTurn";
          grpcPath: "/gestalt.provider.v1.Agent/GetTurn";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/agent/sessions/{session_id}/turns/{turn_id}";
              body: "";
              pathFields: readonly [
                  { name: "session_id"; jsonName: "sessionId" },
                  { name: "turn_id"; jsonName: "turnId" },
              ];
              queryFields: readonly [
                  { name: "provider_name"; jsonName: "providerName" },
              ];
          };
      };
      listInteractions: {
          service: "Agent";
          method: "ListInteractions";
          grpcPath: "/gestalt.provider.v1.Agent/ListInteractions";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/agent/turns/{turn_id}/interactions";
              body: "";
              pathFields: readonly [{ name: "turn_id"; jsonName: "turnId" }];
              queryFields: readonly [
                  { name: "provider_name"; jsonName: "providerName" },
              ];
          };
      };
      listSessions: {
          service: "Agent";
          method: "ListSessions";
          grpcPath: "/gestalt.provider.v1.Agent/ListSessions";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/agent/sessions";
              body: "";
              pathFields: readonly [];
              queryFields: readonly [
                  { name: "session_ids"; jsonName: "sessionIds" },
                  { name: "state"; jsonName: "state" },
                  { name: "limit"; jsonName: "limit" },
                  { name: "summary_only"; jsonName: "summaryOnly" },
                  { name: "provider_name"; jsonName: "providerName" },
              ];
          };
      };
      listTurnEvents: {
          service: "Agent";
          method: "ListTurnEvents";
          grpcPath: "/gestalt.provider.v1.Agent/ListTurnEvents";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/agent/sessions/{session_id}/turns/{turn_id}/events";
              body: "";
              pathFields: readonly [
                  { name: "session_id"; jsonName: "sessionId" },
                  { name: "turn_id"; jsonName: "turnId" },
              ];
              queryFields: readonly [
                  { name: "after_seq"; jsonName: "afterSeq" },
                  { name: "limit"; jsonName: "limit" },
                  { name: "provider_name"; jsonName: "providerName" },
              ];
          };
      };
      listTurns: {
          service: "Agent";
          method: "ListTurns";
          grpcPath: "/gestalt.provider.v1.Agent/ListTurns";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/agent/sessions/{session_id}/turns";
              body: "";
              pathFields: readonly [{ name: "session_id"; jsonName: "sessionId" }];
              queryFields: readonly [
                  { name: "turn_ids"; jsonName: "turnIds" },
                  { name: "status"; jsonName: "status" },
                  { name: "limit"; jsonName: "limit" },
                  { name: "summary_only"; jsonName: "summaryOnly" },
                  { name: "provider_name"; jsonName: "providerName" },
              ];
          };
      };
      resolveInteraction: {
          service: "Agent";
          method: "ResolveInteraction";
          grpcPath: "/gestalt.provider.v1.Agent/ResolveInteraction";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/agent/turns/{turn_id}/interactions/{interaction_id}/resolve";
              body: "*";
              pathFields: readonly [
                  { name: "turn_id"; jsonName: "turnId" },
                  { name: "interaction_id"; jsonName: "interactionId" },
              ];
              queryFields: readonly [];
          };
      };
      updateSession: {
          service: "Agent";
          method: "UpdateSession";
          grpcPath: "/gestalt.provider.v1.Agent/UpdateSession";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "PATCH";
              path: "/api/v2/agent/sessions/{session_id}";
              body: "*";
              pathFields: readonly [{ name: "session_id"; jsonName: "sessionId" }];
              queryFields: readonly [];
          };
      };
  }

• Readonlyapp: {
      invoke: {
          service: "App";
          method: "Invoke";
          grpcPath: "/gestalt.provider.v1.App/Invoke";
          fill: readonly ["context"];
          reject: readonly ["run_as"];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/app/{app}/operations/{operation}";
              body: "*";
              pathFields: readonly [
                  { name: "app"; jsonName: "app" },
                  { name: "operation"; jsonName: "operation" },
              ];
              queryFields: readonly [];
          };
      };
      invokeGraphQL: {
          service: "App";
          method: "InvokeGraphQL";
          grpcPath: "/gestalt.provider.v1.App/InvokeGraphQL";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/app/{app}/graphql";
              body: "*";
              pathFields: readonly [{ name: "app"; jsonName: "app" }];
              queryFields: readonly [];
          };
      };
      invokeStream: {
          service: "App";
          method: "InvokeStream";
          grpcPath: "/gestalt.provider.v1.App/InvokeStream";
          fill: readonly ["context"];
          reject: readonly ["run_as"];
          stream: true;
      };
  }

• Readonlyauthorization: {
      addRelationship: {
          service: "Authorization";
          method: "AddRelationship";
          grpcPath: "/gestalt.provider.v1.Authorization/AddRelationship";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/authorization/relationships";
              body: "*";
              pathFields: readonly [];
              queryFields: readonly [];
          };
      };
      checkAccess: {
          service: "Authorization";
          method: "CheckAccess";
          grpcPath: "/gestalt.provider.v1.Authorization/CheckAccess";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/authorization/access:check";
              body: "*";
              pathFields: readonly [];
              queryFields: readonly [];
          };
      };
      checkAccessMany: {
          service: "Authorization";
          method: "CheckAccessMany";
          grpcPath: "/gestalt.provider.v1.Authorization/CheckAccessMany";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/authorization/access:checkMany";
              body: "*";
              pathFields: readonly [];
              queryFields: readonly [];
          };
      };
      deleteRelationship: {
          service: "Authorization";
          method: "DeleteRelationship";
          grpcPath: "/gestalt.provider.v1.Authorization/DeleteRelationship";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/authorization/relationships:delete";
              body: "*";
              pathFields: readonly [];
              queryFields: readonly [];
          };
      };
      getActiveModelRef: {
          service: "Authorization";
          method: "GetActiveModelRef";
          grpcPath: "/gestalt.provider.v1.Authorization/GetActiveModelRef";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/authorization/models/active";
              body: "";
              pathFields: readonly [];
              queryFields: readonly [];
          };
      };
      listActiveModelResourceTypes: {
          service: "Authorization";
          method: "ListActiveModelResourceTypes";
          grpcPath: "/gestalt.provider.v1.Authorization/ListActiveModelResourceTypes";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/authorization/models/active/resource-types";
              body: "";
              pathFields: readonly [];
              queryFields: readonly [
                  { name: "filter"; jsonName: "filter" },
                  { name: "page_size"; jsonName: "pageSize" },
                  { name: "page_token"; jsonName: "pageToken" },
              ];
          };
      };
      listRelationships: {
          service: "Authorization";
          method: "ListRelationships";
          grpcPath: "/gestalt.provider.v1.Authorization/ListRelationships";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/authorization/relationships";
              body: "";
              pathFields: readonly [];
              queryFields: readonly [
                  { name: "filter"; jsonName: "filter" },
                  { name: "page_size"; jsonName: "pageSize" },
                  { name: "page_token"; jsonName: "pageToken" },
              ];
          };
      };
      setActiveModel: {
          service: "Authorization";
          method: "SetActiveModel";
          grpcPath: "/gestalt.provider.v1.Authorization/SetActiveModel";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "PUT";
              path: "/api/v2/authorization/models/active";
              body: "*";
              pathFields: readonly [];
              queryFields: readonly [];
          };
      };
      setAuthorizationState: {
          service: "Authorization";
          method: "SetAuthorizationState";
          grpcPath: "/gestalt.provider.v1.Authorization/SetAuthorizationState";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "PUT";
              path: "/api/v2/authorization/state";
              body: "*";
              pathFields: readonly [];
              queryFields: readonly [];
          };
      };
  }

• ReadonlyexternalCredentials: {
      createCredential: {
          service: "ExternalCredentials";
          method: "CreateCredential";
          grpcPath: "/gestalt.provider.v1.ExternalCredentials/CreateCredential";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      deleteCredential: {
          service: "ExternalCredentials";
          method: "DeleteCredential";
          grpcPath: "/gestalt.provider.v1.ExternalCredentials/DeleteCredential";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      exchangeCredential: {
          service: "ExternalCredentials";
          method: "ExchangeCredential";
          grpcPath: "/gestalt.provider.v1.ExternalCredentials/ExchangeCredential";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      getCredential: {
          service: "ExternalCredentials";
          method: "GetCredential";
          grpcPath: "/gestalt.provider.v1.ExternalCredentials/GetCredential";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      listCredentials: {
          service: "ExternalCredentials";
          method: "ListCredentials";
          grpcPath: "/gestalt.provider.v1.ExternalCredentials/ListCredentials";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      resolveCredential: {
          service: "ExternalCredentials";
          method: "ResolveCredential";
          grpcPath: "/gestalt.provider.v1.ExternalCredentials/ResolveCredential";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      upsertCredential: {
          service: "ExternalCredentials";
          method: "UpsertCredential";
          grpcPath: "/gestalt.provider.v1.ExternalCredentials/UpsertCredential";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      validateCredentialConfig: {
          service: "ExternalCredentials";
          method: "ValidateCredentialConfig";
          grpcPath: "/gestalt.provider.v1.ExternalCredentials/ValidateCredentialConfig";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
  }

• Readonlyidentity: {
      authorize: {
          service: "Identity";
          method: "Authorize";
          grpcPath: "/gestalt.provider.v1.Identity/Authorize";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/identity/authorize";
              body: "*";
              pathFields: readonly [];
              queryFields: readonly [];
          };
      };
      getGrant: {
          service: "Identity";
          method: "GetGrant";
          grpcPath: "/gestalt.provider.v1.Identity/GetGrant";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/identity/grants/{grant_id}";
              body: "";
              pathFields: readonly [{ name: "grant_id"; jsonName: "grantId" }];
              queryFields: readonly [];
          };
      };
      introspect: {
          service: "Identity";
          method: "Introspect";
          grpcPath: "/gestalt.provider.v1.Identity/Introspect";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/identity/introspect";
              body: "*";
              pathFields: readonly [];
              queryFields: readonly [];
          };
      };
      listGrants: {
          service: "Identity";
          method: "ListGrants";
          grpcPath: "/gestalt.provider.v1.Identity/ListGrants";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/identity/grants";
              body: "";
              pathFields: readonly [];
              queryFields: readonly [];
          };
      };
      revokeGrant: {
          service: "Identity";
          method: "RevokeGrant";
          grpcPath: "/gestalt.provider.v1.Identity/RevokeGrant";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "DELETE";
              path: "/api/v2/identity/grants/{grant_id}";
              body: "";
              pathFields: readonly [{ name: "grant_id"; jsonName: "grantId" }];
              queryFields: readonly [];
          };
      };
      token: {
          service: "Identity";
          method: "Token";
          grpcPath: "/gestalt.provider.v1.Identity/Token";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/identity/token";
              body: "*";
              pathFields: readonly [];
              queryFields: readonly [];
          };
      };
      userInfo: {
          service: "Identity";
          method: "UserInfo";
          grpcPath: "/gestalt.provider.v1.Identity/UserInfo";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/identity/userinfo";
              body: "";
              pathFields: readonly [];
              queryFields: readonly [];
          };
      };
  }

• ReadonlyindexedDB: {
      add: {
          service: "IndexedDB";
          method: "Add";
          grpcPath: "/gestalt.provider.v1.IndexedDB/Add";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      clear: {
          service: "IndexedDB";
          method: "Clear";
          grpcPath: "/gestalt.provider.v1.IndexedDB/Clear";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      count: {
          service: "IndexedDB";
          method: "Count";
          grpcPath: "/gestalt.provider.v1.IndexedDB/Count";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      createIndex: {
          service: "IndexedDB";
          method: "CreateIndex";
          grpcPath: "/gestalt.provider.v1.IndexedDB/CreateIndex";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      createObjectStore: {
          service: "IndexedDB";
          method: "CreateObjectStore";
          grpcPath: "/gestalt.provider.v1.IndexedDB/CreateObjectStore";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      delete: {
          service: "IndexedDB";
          method: "Delete";
          grpcPath: "/gestalt.provider.v1.IndexedDB/Delete";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      deleteIndex: {
          service: "IndexedDB";
          method: "DeleteIndex";
          grpcPath: "/gestalt.provider.v1.IndexedDB/DeleteIndex";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      deleteObjectStore: {
          service: "IndexedDB";
          method: "DeleteObjectStore";
          grpcPath: "/gestalt.provider.v1.IndexedDB/DeleteObjectStore";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      deleteRange: {
          service: "IndexedDB";
          method: "DeleteRange";
          grpcPath: "/gestalt.provider.v1.IndexedDB/DeleteRange";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      get: {
          service: "IndexedDB";
          method: "Get";
          grpcPath: "/gestalt.provider.v1.IndexedDB/Get";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      getAll: {
          service: "IndexedDB";
          method: "GetAll";
          grpcPath: "/gestalt.provider.v1.IndexedDB/GetAll";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      getAllKeys: {
          service: "IndexedDB";
          method: "GetAllKeys";
          grpcPath: "/gestalt.provider.v1.IndexedDB/GetAllKeys";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      getKey: {
          service: "IndexedDB";
          method: "GetKey";
          grpcPath: "/gestalt.provider.v1.IndexedDB/GetKey";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      indexCount: {
          service: "IndexedDB";
          method: "IndexCount";
          grpcPath: "/gestalt.provider.v1.IndexedDB/IndexCount";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      indexDelete: {
          service: "IndexedDB";
          method: "IndexDelete";
          grpcPath: "/gestalt.provider.v1.IndexedDB/IndexDelete";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      indexGet: {
          service: "IndexedDB";
          method: "IndexGet";
          grpcPath: "/gestalt.provider.v1.IndexedDB/IndexGet";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      indexGetAll: {
          service: "IndexedDB";
          method: "IndexGetAll";
          grpcPath: "/gestalt.provider.v1.IndexedDB/IndexGetAll";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      indexGetAllKeys: {
          service: "IndexedDB";
          method: "IndexGetAllKeys";
          grpcPath: "/gestalt.provider.v1.IndexedDB/IndexGetAllKeys";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      indexGetKey: {
          service: "IndexedDB";
          method: "IndexGetKey";
          grpcPath: "/gestalt.provider.v1.IndexedDB/IndexGetKey";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
      put: {
          service: "IndexedDB";
          method: "Put";
          grpcPath: "/gestalt.provider.v1.IndexedDB/Put";
          fill: readonly [];
          reject: readonly [];
          stream: false;
      };
  }

• ReadonlyremoteManagement: {
      createRemote: {
          service: "RemoteManagement";
          method: "CreateRemote";
          grpcPath: "/gestalt.provider.v1.RemoteManagement/CreateRemote";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/remotes";
              body: "*";
              pathFields: readonly [];
              queryFields: readonly [];
          };
      };
      deleteRemote: {
          service: "RemoteManagement";
          method: "DeleteRemote";
          grpcPath: "/gestalt.provider.v1.RemoteManagement/DeleteRemote";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "DELETE";
              path: "/api/v2/remotes/{id}";
              body: "";
              pathFields: readonly [{ name: "id"; jsonName: "id" }];
              queryFields: readonly [
                  { name: "expected_generation"; jsonName: "expectedGeneration" },
              ];
          };
      };
      listRemotes: {
          service: "RemoteManagement";
          method: "ListRemotes";
          grpcPath: "/gestalt.provider.v1.RemoteManagement/ListRemotes";
          fill: readonly [];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/remotes";
              body: "";
              pathFields: readonly [];
              queryFields: readonly [];
          };
      };
  }

• Readonlyworkflow: {
      applyDefinition: {
          service: "Workflow";
          method: "ApplyDefinition";
          grpcPath: "/gestalt.provider.v1.Workflow/ApplyDefinition";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/workflow/definitions:apply";
              body: "*";
              pathFields: readonly [];
              queryFields: readonly [];
          };
      };
      cancelRun: {
          service: "Workflow";
          method: "CancelRun";
          grpcPath: "/gestalt.provider.v1.Workflow/CancelRun";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/workflow/runs/{run_id}:cancel";
              body: "*";
              pathFields: readonly [{ name: "run_id"; jsonName: "runId" }];
              queryFields: readonly [];
          };
      };
      deleteDefinition: {
          service: "Workflow";
          method: "DeleteDefinition";
          grpcPath: "/gestalt.provider.v1.Workflow/DeleteDefinition";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "DELETE";
              path: "/api/v2/workflow/definitions/{definition_id}";
              body: "";
              pathFields: readonly [
                  { name: "definition_id"; jsonName: "definitionId" },
              ];
              queryFields: readonly [{ name: "provider"; jsonName: "provider" }];
          };
      };
      getDefinition: {
          service: "Workflow";
          method: "GetDefinition";
          grpcPath: "/gestalt.provider.v1.Workflow/GetDefinition";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/workflow/definitions/{definition_id}";
              body: "";
              pathFields: readonly [
                  { name: "definition_id"; jsonName: "definitionId" },
              ];
              queryFields: readonly [{ name: "provider"; jsonName: "provider" }];
          };
      };
      getRun: {
          service: "Workflow";
          method: "GetRun";
          grpcPath: "/gestalt.provider.v1.Workflow/GetRun";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/workflow/runs/{run_id}";
              body: "";
              pathFields: readonly [{ name: "run_id"; jsonName: "runId" }];
              queryFields: readonly [{ name: "provider"; jsonName: "provider" }];
          };
      };
      getRunEvents: {
          service: "Workflow";
          method: "GetRunEvents";
          grpcPath: "/gestalt.provider.v1.Workflow/GetRunEvents";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/workflow/runs/{run_id}/events";
              body: "";
              pathFields: readonly [{ name: "run_id"; jsonName: "runId" }];
              queryFields: readonly [{ name: "provider"; jsonName: "provider" }];
          };
      };
      getRunOutput: {
          service: "Workflow";
          method: "GetRunOutput";
          grpcPath: "/gestalt.provider.v1.Workflow/GetRunOutput";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/workflow/runs/{run_id}/output";
              body: "";
              pathFields: readonly [{ name: "run_id"; jsonName: "runId" }];
              queryFields: readonly [{ name: "provider"; jsonName: "provider" }];
          };
      };
      listDefinitions: {
          service: "Workflow";
          method: "ListDefinitions";
          grpcPath: "/gestalt.provider.v1.Workflow/ListDefinitions";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/workflow/definitions";
              body: "";
              pathFields: readonly [];
              queryFields: readonly [{ name: "provider"; jsonName: "provider" }];
          };
      };
      listRuns: {
          service: "Workflow";
          method: "ListRuns";
          grpcPath: "/gestalt.provider.v1.Workflow/ListRuns";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "GET";
              path: "/api/v2/workflow/runs";
              body: "";
              pathFields: readonly [];
              queryFields: readonly [
                  { name: "page_size"; jsonName: "pageSize" },
                  { name: "page_token"; jsonName: "pageToken" },
                  { name: "status"; jsonName: "status" },
                  { name: "target_app"; jsonName: "targetApp" },
                  { name: "provider"; jsonName: "provider" },
              ];
          };
      };
      setActivationPaused: {
          service: "Workflow";
          method: "SetActivationPaused";
          grpcPath: "/gestalt.provider.v1.Workflow/SetActivationPaused";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/workflow/definitions/{definition_id}/activations/{activation_id}:setPaused";
              body: "*";
              pathFields: readonly [
                  { name: "definition_id"; jsonName: "definitionId" },
                  { name: "activation_id"; jsonName: "activationId" },
              ];
              queryFields: readonly [];
          };
      };
      setDefinitionPaused: {
          service: "Workflow";
          method: "SetDefinitionPaused";
          grpcPath: "/gestalt.provider.v1.Workflow/SetDefinitionPaused";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/workflow/definitions/{definition_id}:setPaused";
              body: "*";
              pathFields: readonly [
                  { name: "definition_id"; jsonName: "definitionId" },
              ];
              queryFields: readonly [];
          };
      };
      signalOrStartRun: {
          service: "Workflow";
          method: "SignalOrStartRun";
          grpcPath: "/gestalt.provider.v1.Workflow/SignalOrStartRun";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/workflow/definitions/{definition_id}:signalOrStart";
              body: "*";
              pathFields: readonly [
                  { name: "definition_id"; jsonName: "definitionId" },
              ];
              queryFields: readonly [];
          };
      };
      signalRun: {
          service: "Workflow";
          method: "SignalRun";
          grpcPath: "/gestalt.provider.v1.Workflow/SignalRun";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/workflow/runs/{run_id}:signal";
              body: "*";
              pathFields: readonly [{ name: "run_id"; jsonName: "runId" }];
              queryFields: readonly [];
          };
      };
      startRun: {
          service: "Workflow";
          method: "StartRun";
          grpcPath: "/gestalt.provider.v1.Workflow/StartRun";
          fill: readonly ["context"];
          reject: readonly [];
          stream: false;
          http: {
              verb: "POST";
              path: "/api/v2/workflow/definitions/{definition_id}/runs";
              body: "*";
              pathFields: readonly [
                  { name: "definition_id"; jsonName: "definitionId" },
              ];
              queryFields: readonly [];
          };
      };
  }