npm - @confighub/rtk-query - Versions diffs - 0.1.0 - Mend

@confighub/rtk-query 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/index.cjs ADDED Viewed

@@ -0,0 +1,2654 @@
+'use strict';
+var react = require('@reduxjs/toolkit/query/react');
+// src/baseApi.ts
+var MERGE_PATCH_PREFIXES = ["patch", "bulkPatch", "bulkCreate", "patchView"];
+var apiBaseUrl = (raw) => {
+  const trimmed = raw.replace(/\/+$/, "");
+  return trimmed.endsWith("/api") ? trimmed : trimmed + "/api";
+};
+var config = null;
+var inner = null;
+function configureConfigHub(cfg) {
+  config = cfg;
+  inner = react.fetchBaseQuery({
+    baseUrl: apiBaseUrl(cfg.baseUrl),
+    isJsonContentType: (headers) => (headers.get("Content-Type") ?? "").includes("json"),
+    prepareHeaders: async (headers, { endpoint }) => {
+      const token = await cfg.getToken?.();
+      if (token) headers.set("Authorization", `Bearer ${token}`);
+      if (MERGE_PATCH_PREFIXES.some((p) => endpoint.startsWith(p))) {
+        headers.set("Content-Type", "application/merge-patch+json");
+      }
+      return headers;
+    }
+  });
+}
+var baseQuery = async (args, api, extraOptions) => {
+  if (!inner || !config) {
+    throw new Error(
+      "configureConfigHub({ baseUrl, getToken }) must be called before dispatching ConfigHub queries"
+    );
+  }
+  const result = await inner(args, api, extraOptions);
+  if (result.error && result.error.status === 401) {
+    await config.onUnauthorized?.();
+  }
+  return result;
+};
+var confighubApi = react.createApi({
+  reducerPath: "confighubApi",
+  baseQuery,
+  endpoints: () => ({})
+});
+// src/confighubApi.gen.ts
+var addTagTypes = [
+  "Space",
+  "Attribute",
+  "BridgeWorker",
+  "QueuedOperation",
+  "ChangeSet",
+  "Filter",
+  "Function",
+  "Meta",
+  "Invocation",
+  "Link",
+  "UserInfo",
+  "OAuthClient",
+  "Organization",
+  "OrganizationMember",
+  "Release",
+  "Revision",
+  "BridgeWorkerStatus",
+  "Tag",
+  "Target",
+  "Trigger",
+  "Unit",
+  "Mutation",
+  "UnitAction",
+  "UnitEvent",
+  "View",
+  "User"
+];
+var injectedRtkApi = confighubApi.enhanceEndpoints({
+  addTagTypes
+}).injectEndpoints({
+  endpoints: (build) => ({
+    bulkDeleteSpaces: build.mutation({
+      query: (queryArg) => ({
+        url: `/_space`,
+        method: "DELETE",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          recursive: queryArg.recursive,
+          recursive_force: queryArg.recursiveForce
+        }
+      }),
+      invalidatesTags: ["Space"]
+    }),
+    bulkPatchSpaces: build.mutation({
+      query: (queryArg) => ({
+        url: `/_space`,
+        method: "PATCH",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          refresh_triggers: queryArg.refreshTriggers
+        }
+      }),
+      invalidatesTags: ["Space"]
+    }),
+    bulkCreateSpaces: build.mutation({
+      query: (queryArg) => ({
+        url: `/_space`,
+        method: "POST",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          name_prefixes: queryArg.namePrefixes,
+          variant_labels: queryArg.variantLabels,
+          name_pattern: queryArg.namePattern,
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["Space"]
+    }),
+    bulkDeleteAttributes: build.mutation({
+      query: (queryArg) => ({
+        url: `/attribute`,
+        method: "DELETE",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["Attribute"]
+    }),
+    listAllAttributes: build.query({
+      query: (queryArg) => ({
+        url: `/attribute`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Attribute"]
+    }),
+    bulkPatchAttributes: build.mutation({
+      query: (queryArg) => ({
+        url: `/attribute`,
+        method: "PATCH",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["Attribute"]
+    }),
+    bulkCreateAttributes: build.mutation({
+      query: (queryArg) => ({
+        url: `/attribute`,
+        method: "POST",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          name_prefixes: queryArg.namePrefixes,
+          where_space: queryArg.whereSpace,
+          filter_space: queryArg.filterSpace,
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["Attribute"]
+    }),
+    bulkDeleteBridgeWorkers: build.mutation({
+      query: (queryArg) => ({
+        url: `/bridge_worker`,
+        method: "DELETE",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["BridgeWorker"]
+    }),
+    listAllBridgeWorkers: build.query({
+      query: (queryArg) => ({
+        url: `/bridge_worker`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select,
+          summary: queryArg.summary
+        }
+      }),
+      providesTags: ["BridgeWorker"]
+    }),
+    bulkPatchBridgeWorkers: build.mutation({
+      query: (queryArg) => ({
+        url: `/bridge_worker`,
+        method: "PATCH",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["BridgeWorker"]
+    }),
+    createActionResult: build.mutation({
+      query: (queryArg) => ({
+        url: `/bridge_worker/${queryArg.bridgeWorkerId}/action_result`,
+        method: "POST",
+        body: queryArg.actionResult
+      }),
+      invalidatesTags: ["BridgeWorker"]
+    }),
+    getSelf: build.query({
+      query: (queryArg) => ({
+        url: `/bridge_worker/${queryArg.bridgeWorkerId}/me`
+      }),
+      providesTags: ["BridgeWorker"]
+    }),
+    listQueuedOperations: build.query({
+      query: (queryArg) => ({
+        url: `/bridge_worker/${queryArg.bridgeWorkerId}/queued_operation`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains
+        }
+      }),
+      providesTags: ["QueuedOperation"]
+    }),
+    getQueuedOperation: build.query({
+      query: (queryArg) => ({
+        url: `/bridge_worker/${queryArg.bridgeWorkerId}/queued_operation/${queryArg.queuedOperationId}`
+      }),
+      providesTags: ["QueuedOperation"]
+    }),
+    streamBridgeWorker: build.mutation({
+      query: (queryArg) => ({
+        url: `/bridge_worker/${queryArg.bridgeWorkerId}/stream`,
+        method: "POST"
+      }),
+      invalidatesTags: ["BridgeWorker"]
+    }),
+    userCreateActionResult: build.mutation({
+      query: (queryArg) => ({
+        url: `/bridge_worker/${queryArg.bridgeWorkerId}/user_action_result`,
+        method: "POST",
+        body: queryArg.actionResult
+      }),
+      invalidatesTags: ["BridgeWorker"]
+    }),
+    bulkDeleteChangeSets: build.mutation({
+      query: (queryArg) => ({
+        url: `/change_set`,
+        method: "DELETE",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["ChangeSet"]
+    }),
+    listAllChangeSets: build.query({
+      query: (queryArg) => ({
+        url: `/change_set`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["ChangeSet"]
+    }),
+    bulkPatchChangeSets: build.mutation({
+      query: (queryArg) => ({
+        url: `/change_set`,
+        method: "PATCH",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["ChangeSet"]
+    }),
+    bulkCreateChangeSets: build.mutation({
+      query: (queryArg) => ({
+        url: `/change_set`,
+        method: "POST",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          name_prefixes: queryArg.namePrefixes,
+          variant_labels: queryArg.variantLabels,
+          name_pattern: queryArg.namePattern,
+          where_space: queryArg.whereSpace,
+          filter_space: queryArg.filterSpace,
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["ChangeSet"]
+    }),
+    bulkDeleteFilters: build.mutation({
+      query: (queryArg) => ({
+        url: `/filter`,
+        method: "DELETE",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["Filter"]
+    }),
+    listAllFilters: build.query({
+      query: (queryArg) => ({
+        url: `/filter`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select,
+          entity: queryArg.entity,
+          id: queryArg.id
+        }
+      }),
+      providesTags: ["Filter"]
+    }),
+    bulkPatchFilters: build.mutation({
+      query: (queryArg) => ({
+        url: `/filter`,
+        method: "PATCH",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["Filter"]
+    }),
+    bulkCreateFilters: build.mutation({
+      query: (queryArg) => ({
+        url: `/filter`,
+        method: "POST",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          name_prefixes: queryArg.namePrefixes,
+          variant_labels: queryArg.variantLabels,
+          name_pattern: queryArg.namePattern,
+          where_space: queryArg.whereSpace,
+          filter_space: queryArg.filterSpace,
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["Filter"]
+    }),
+    listOrgFunctions: build.query({
+      query: (queryArg) => ({
+        url: `/function`,
+        params: {
+          executor_space: queryArg.executorSpace,
+          where: queryArg.where
+        }
+      }),
+      providesTags: ["Function"]
+    }),
+    invokeFunctionsOnOrg: build.mutation({
+      query: (queryArg) => ({
+        url: `/function/invoke`,
+        method: "POST",
+        body: queryArg.functionInvocationsRequest,
+        params: {
+          executor_space: queryArg.executorSpace,
+          dry_run: queryArg.dryRun,
+          change_set_id: queryArg.changeSetId,
+          subgroup: queryArg.subgroup,
+          other_data_source: queryArg.otherDataSource,
+          where: queryArg.where,
+          filter: queryArg.filter,
+          resource_type: queryArg.resourceType,
+          where_data: queryArg.whereData,
+          where_trigger: queryArg.whereTrigger,
+          trigger_filter: queryArg.triggerFilter,
+          triggers_passed: queryArg.triggersPassed,
+          view: queryArg.view
+        }
+      }),
+      invalidatesTags: ["Function"]
+    }),
+    apiInfo: build.query({
+      query: () => ({ url: `/info` }),
+      providesTags: ["Meta"]
+    }),
+    bulkDeleteInvocations: build.mutation({
+      query: (queryArg) => ({
+        url: `/invocation`,
+        method: "DELETE",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["Invocation"]
+    }),
+    listAllInvocations: build.query({
+      query: (queryArg) => ({
+        url: `/invocation`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Invocation"]
+    }),
+    bulkPatchInvocations: build.mutation({
+      query: (queryArg) => ({
+        url: `/invocation`,
+        method: "PATCH",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["Invocation"]
+    }),
+    bulkCreateInvocations: build.mutation({
+      query: (queryArg) => ({
+        url: `/invocation`,
+        method: "POST",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          name_prefixes: queryArg.namePrefixes,
+          variant_labels: queryArg.variantLabels,
+          name_pattern: queryArg.namePattern,
+          where_space: queryArg.whereSpace,
+          filter_space: queryArg.filterSpace,
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["Invocation"]
+    }),
+    bulkDeleteLinks: build.mutation({
+      query: (queryArg) => ({
+        url: `/link`,
+        method: "DELETE",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["Link"]
+    }),
+    searchListLinks: build.query({
+      query: (queryArg) => ({
+        url: `/link`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Link"]
+    }),
+    bulkPatchLinks: build.mutation({
+      query: (queryArg) => ({
+        url: `/link`,
+        method: "PATCH",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          reverse: queryArg.reverse
+        }
+      }),
+      invalidatesTags: ["Link"]
+    }),
+    bulkCreateLinks: build.mutation({
+      query: (queryArg) => ({
+        url: `/link`,
+        method: "POST",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          reverse: queryArg.reverse,
+          from_downstream_where: queryArg.fromDownstreamWhere,
+          to_downstream_where: queryArg.toDownstreamWhere,
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["Link"]
+    }),
+    getMe: build.query({
+      query: () => ({ url: `/me` }),
+      providesTags: ["UserInfo"]
+    }),
+    listOAuthClients: build.query({
+      query: () => ({ url: `/oauth_client` }),
+      providesTags: ["OAuthClient"]
+    }),
+    createOAuthClient: build.mutation({
+      query: (queryArg) => ({
+        url: `/oauth_client`,
+        method: "POST",
+        body: queryArg.oAuthClient
+      }),
+      invalidatesTags: ["OAuthClient"]
+    }),
+    deleteOAuthClient: build.mutation({
+      query: (queryArg) => ({
+        url: `/oauth_client/${queryArg.oauthClient}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: ["OAuthClient"]
+    }),
+    getOAuthClient: build.query({
+      query: (queryArg) => ({ url: `/oauth_client/${queryArg.oauthClient}` }),
+      providesTags: ["OAuthClient"]
+    }),
+    listOrganizations: build.query({
+      query: (queryArg) => ({
+        url: `/organization`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Organization"]
+    }),
+    createOrganization: build.mutation({
+      query: (queryArg) => ({
+        url: `/organization`,
+        method: "POST",
+        body: queryArg.organization,
+        params: {
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["Organization"]
+    }),
+    deleteOrganization: build.mutation({
+      query: (queryArg) => ({
+        url: `/organization/${queryArg.organizationId}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: ["Organization"]
+    }),
+    getOrganization: build.query({
+      query: (queryArg) => ({
+        url: `/organization/${queryArg.organizationId}`,
+        params: {
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Organization"]
+    }),
+    updateOrganization: build.mutation({
+      query: (queryArg) => ({
+        url: `/organization/${queryArg.organizationId}`,
+        method: "PUT",
+        body: queryArg.organization
+      }),
+      invalidatesTags: ["Organization"]
+    }),
+    listOrganizationMembers: build.query({
+      query: (queryArg) => ({
+        url: `/organization/${queryArg.organizationId}/organization_member`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains
+        }
+      }),
+      providesTags: ["OrganizationMember"]
+    }),
+    createOrganizationMember: build.mutation({
+      query: (queryArg) => ({
+        url: `/organization/${queryArg.organizationId}/organization_member`,
+        method: "POST",
+        body: queryArg.organizationMember
+      }),
+      invalidatesTags: ["OrganizationMember"]
+    }),
+    deleteOrganizationMember: build.mutation({
+      query: (queryArg) => ({
+        url: `/organization/${queryArg.organizationId}/organization_member/${queryArg.organizationMemberId}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: ["OrganizationMember"]
+    }),
+    getOrganizationMember: build.query({
+      query: (queryArg) => ({
+        url: `/organization/${queryArg.organizationId}/organization_member/${queryArg.organizationMemberId}`
+      }),
+      providesTags: ["OrganizationMember"]
+    }),
+    listAllReleases: build.query({
+      query: (queryArg) => ({
+        url: `/release`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Release"]
+    }),
+    listAllRevisions: build.query({
+      query: (queryArg) => ({
+        url: `/revision`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Revision"]
+    }),
+    listSpaces: build.query({
+      query: (queryArg) => ({
+        url: `/space`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select,
+          summary: queryArg.summary
+        }
+      }),
+      providesTags: ["Space"]
+    }),
+    createSpace: build.mutation({
+      query: (queryArg) => ({
+        url: `/space`,
+        method: "POST",
+        body: queryArg.space,
+        params: {
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["Space"]
+    }),
+    deleteSpace: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}`,
+        method: "DELETE",
+        params: {
+          recursive: queryArg.recursive,
+          recursive_force: queryArg.recursiveForce
+        }
+      }),
+      invalidatesTags: ["Space"]
+    }),
+    getSpace: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}`,
+        params: {
+          include: queryArg.include,
+          select: queryArg.select,
+          summary: queryArg.summary
+        }
+      }),
+      providesTags: ["Space"]
+    }),
+    patchSpace: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}`,
+        method: "PATCH",
+        body: queryArg.body,
+        params: {
+          refresh_triggers: queryArg.refreshTriggers
+        }
+      }),
+      invalidatesTags: ["Space"]
+    }),
+    updateSpace: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}`,
+        method: "PUT",
+        body: queryArg.space,
+        params: {
+          refresh_triggers: queryArg.refreshTriggers
+        }
+      }),
+      invalidatesTags: ["Space"]
+    }),
+    listAttributes: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/attribute`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Attribute"]
+    }),
+    createAttribute: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/attribute`,
+        method: "POST",
+        body: queryArg.attribute,
+        params: {
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["Attribute"]
+    }),
+    deleteAttribute: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/attribute/${queryArg.attributeId}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: ["Attribute"]
+    }),
+    getAttribute: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/attribute/${queryArg.attributeId}`,
+        params: {
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Attribute"]
+    }),
+    patchAttribute: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/attribute/${queryArg.attributeId}`,
+        method: "PATCH",
+        body: queryArg.body
+      }),
+      invalidatesTags: ["Attribute"]
+    }),
+    updateAttribute: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/attribute/${queryArg.attributeId}`,
+        method: "PUT",
+        body: queryArg.attribute
+      }),
+      invalidatesTags: ["Attribute"]
+    }),
+    listBridgeWorkers: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/bridge_worker`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["BridgeWorker"]
+    }),
+    createBridgeWorker: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/bridge_worker`,
+        method: "POST",
+        body: queryArg.bridgeWorker,
+        params: {
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["BridgeWorker"]
+    }),
+    deleteBridgeWorker: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/bridge_worker/${queryArg.bridgeWorkerId}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: ["BridgeWorker"]
+    }),
+    getBridgeWorker: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/bridge_worker/${queryArg.bridgeWorkerId}`,
+        params: {
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["BridgeWorker"]
+    }),
+    patchBridgeWorker: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/bridge_worker/${queryArg.bridgeWorkerId}`,
+        method: "PATCH",
+        body: queryArg.body
+      }),
+      invalidatesTags: ["BridgeWorker"]
+    }),
+    updateBridgeWorker: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/bridge_worker/${queryArg.bridgeWorkerId}`,
+        method: "PUT",
+        body: queryArg.bridgeWorker
+      }),
+      invalidatesTags: ["BridgeWorker"]
+    }),
+    listBridgeWorkerFunctions: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/bridge_worker/${queryArg.bridgeWorkerId}/function`
+      }),
+      providesTags: ["BridgeWorker"]
+    }),
+    listBridgeWorkerStatuses: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/bridge_worker/${queryArg.bridgeWorkerId}/status`
+      }),
+      providesTags: ["BridgeWorkerStatus"]
+    }),
+    getBridgeWorkerStatus: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/bridge_worker/${queryArg.bridgeWorkerId}/status/${queryArg.statusId}`
+      }),
+      providesTags: ["BridgeWorkerStatus"]
+    }),
+    listChangeSets: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/change_set`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["ChangeSet"]
+    }),
+    createChangeSet: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/change_set`,
+        method: "POST",
+        body: queryArg.changeSet,
+        params: {
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["ChangeSet"]
+    }),
+    deleteChangeSet: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/change_set/${queryArg.changeSetId}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: ["ChangeSet"]
+    }),
+    getChangeSet: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/change_set/${queryArg.changeSetId}`,
+        params: {
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["ChangeSet"]
+    }),
+    patchChangeSet: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/change_set/${queryArg.changeSetId}`,
+        method: "PATCH",
+        body: queryArg.body
+      }),
+      invalidatesTags: ["ChangeSet"]
+    }),
+    updateChangeSet: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/change_set/${queryArg.changeSetId}`,
+        method: "PUT",
+        body: queryArg.changeSet
+      }),
+      invalidatesTags: ["ChangeSet"]
+    }),
+    listFilters: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/filter`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select,
+          entity: queryArg.entity,
+          id: queryArg.id
+        }
+      }),
+      providesTags: ["Filter"]
+    }),
+    createFilter: build.mutation(
+      {
+        query: (queryArg) => ({
+          url: `/space/${queryArg.spaceId}/filter`,
+          method: "POST",
+          body: queryArg.filter,
+          params: {
+            allow_exists: queryArg.allowExists
+          }
+        }),
+        invalidatesTags: ["Filter"]
+      }
+    ),
+    deleteFilter: build.mutation(
+      {
+        query: (queryArg) => ({
+          url: `/space/${queryArg.spaceId}/filter/${queryArg.filterId}`,
+          method: "DELETE"
+        }),
+        invalidatesTags: ["Filter"]
+      }
+    ),
+    getFilter: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/filter/${queryArg.filterId}`,
+        params: {
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Filter"]
+    }),
+    patchFilter: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/filter/${queryArg.filterId}`,
+        method: "PATCH",
+        body: queryArg.body
+      }),
+      invalidatesTags: ["Filter"]
+    }),
+    updateFilter: build.mutation(
+      {
+        query: (queryArg) => ({
+          url: `/space/${queryArg.spaceId}/filter/${queryArg.filterId}`,
+          method: "PUT",
+          body: queryArg.filter
+        }),
+        invalidatesTags: ["Filter"]
+      }
+    ),
+    listFunctions: build.query(
+      {
+        query: (queryArg) => ({
+          url: `/space/${queryArg.spaceId}/function`,
+          params: {
+            entity: queryArg.entity,
+            id: queryArg.id,
+            where: queryArg.where
+          }
+        }),
+        providesTags: ["Function"]
+      }
+    ),
+    invokeFunctions: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/function/invoke`,
+        method: "POST",
+        body: queryArg.functionInvocationsRequest,
+        params: {
+          unit_id: queryArg.unitId,
+          revision_id: queryArg.revisionId,
+          dry_run: queryArg.dryRun,
+          change_set_id: queryArg.changeSetId,
+          subgroup: queryArg.subgroup,
+          other_data_source: queryArg.otherDataSource,
+          where: queryArg.where,
+          filter: queryArg.filter,
+          resource_type: queryArg.resourceType,
+          where_data: queryArg.whereData,
+          where_trigger: queryArg.whereTrigger,
+          trigger_filter: queryArg.triggerFilter,
+          triggers_passed: queryArg.triggersPassed,
+          view: queryArg.view
+        }
+      }),
+      invalidatesTags: ["Function"]
+    }),
+    listInvocations: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/invocation`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Invocation"]
+    }),
+    createInvocation: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/invocation`,
+        method: "POST",
+        body: queryArg.invocation,
+        params: {
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["Invocation"]
+    }),
+    deleteInvocation: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/invocation/${queryArg.invocationId}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: ["Invocation"]
+    }),
+    getInvocation: build.query(
+      {
+        query: (queryArg) => ({
+          url: `/space/${queryArg.spaceId}/invocation/${queryArg.invocationId}`,
+          params: {
+            include: queryArg.include,
+            select: queryArg.select
+          }
+        }),
+        providesTags: ["Invocation"]
+      }
+    ),
+    patchInvocation: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/invocation/${queryArg.invocationId}`,
+        method: "PATCH",
+        body: queryArg.body
+      }),
+      invalidatesTags: ["Invocation"]
+    }),
+    updateInvocation: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/invocation/${queryArg.invocationId}`,
+        method: "PUT",
+        body: queryArg.invocation
+      }),
+      invalidatesTags: ["Invocation"]
+    }),
+    listLinks: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/link`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Link"]
+    }),
+    createLink: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/link`,
+        method: "POST",
+        body: queryArg.link,
+        params: {
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["Link"]
+    }),
+    deleteLink: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/link/${queryArg.linkId}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: ["Link"]
+    }),
+    getLink: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/link/${queryArg.linkId}`,
+        params: {
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Link"]
+    }),
+    patchLink: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/link/${queryArg.linkId}`,
+        method: "PATCH",
+        body: queryArg.body,
+        params: {
+          reverse: queryArg.reverse
+        }
+      }),
+      invalidatesTags: ["Link"]
+    }),
+    updateLink: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/link/${queryArg.linkId}`,
+        method: "PUT",
+        body: queryArg.link
+      }),
+      invalidatesTags: ["Link"]
+    }),
+    listExtendedReleases: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/release`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Release"]
+    }),
+    publishRelease: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/release`,
+        method: "POST",
+        body: queryArg.releasePublishRequest
+      }),
+      invalidatesTags: ["Release"]
+    }),
+    withdrawRelease: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/release/${queryArg.releaseId}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: []
+    }),
+    getExtendedRelease: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/release/${queryArg.releaseId}`,
+        params: {
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Release"]
+    }),
+    listTags: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/tag`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Tag"]
+    }),
+    createTag: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/tag`,
+        method: "POST",
+        body: queryArg.tag,
+        params: {
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["Tag"]
+    }),
+    deleteTag: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/tag/${queryArg.tagId}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: ["Tag"]
+    }),
+    getTag: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/tag/${queryArg.tagId}`,
+        params: {
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Tag"]
+    }),
+    patchTag: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/tag/${queryArg.tagId}`,
+        method: "PATCH",
+        body: queryArg.body
+      }),
+      invalidatesTags: ["Tag"]
+    }),
+    updateTag: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/tag/${queryArg.tagId}`,
+        method: "PUT",
+        body: queryArg.tag
+      }),
+      invalidatesTags: ["Tag"]
+    }),
+    listTargets: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/target`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Target"]
+    }),
+    createTarget: build.mutation(
+      {
+        query: (queryArg) => ({
+          url: `/space/${queryArg.spaceId}/target`,
+          method: "POST",
+          body: queryArg.target,
+          params: {
+            allow_exists: queryArg.allowExists
+          }
+        }),
+        invalidatesTags: ["Target"]
+      }
+    ),
+    deleteTarget: build.mutation(
+      {
+        query: (queryArg) => ({
+          url: `/space/${queryArg.spaceId}/target/${queryArg.targetId}`,
+          method: "DELETE"
+        }),
+        invalidatesTags: ["Target"]
+      }
+    ),
+    getTarget: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/target/${queryArg.targetId}`,
+        params: {
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Target"]
+    }),
+    patchTarget: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/target/${queryArg.targetId}`,
+        method: "PATCH",
+        body: queryArg.body,
+        params: {
+          refresh_triggers: queryArg.refreshTriggers
+        }
+      }),
+      invalidatesTags: ["Target"]
+    }),
+    updateTarget: build.mutation(
+      {
+        query: (queryArg) => ({
+          url: `/space/${queryArg.spaceId}/target/${queryArg.targetId}`,
+          method: "PUT",
+          body: queryArg.target,
+          params: {
+            refresh_triggers: queryArg.refreshTriggers
+          }
+        }),
+        invalidatesTags: ["Target"]
+      }
+    ),
+    listTriggers: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/trigger`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Trigger"]
+    }),
+    createTrigger: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/trigger`,
+        method: "POST",
+        body: queryArg.trigger,
+        params: {
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["Trigger"]
+    }),
+    deleteTrigger: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/trigger/${queryArg.triggerId}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: ["Trigger"]
+    }),
+    getTrigger: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/trigger/${queryArg.triggerId}`,
+        params: {
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Trigger"]
+    }),
+    patchTrigger: build.mutation(
+      {
+        query: (queryArg) => ({
+          url: `/space/${queryArg.spaceId}/trigger/${queryArg.triggerId}`,
+          method: "PATCH",
+          body: queryArg.body
+        }),
+        invalidatesTags: ["Trigger"]
+      }
+    ),
+    updateTrigger: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/trigger/${queryArg.triggerId}`,
+        method: "PUT",
+        body: queryArg.trigger
+      }),
+      invalidatesTags: ["Trigger"]
+    }),
+    listUnits: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select,
+          resource_type: queryArg.resourceType,
+          where_data: queryArg.whereData,
+          where_trigger: queryArg.whereTrigger,
+          trigger_filter: queryArg.triggerFilter,
+          triggers_passed: queryArg.triggersPassed,
+          view: queryArg.view
+        }
+      }),
+      providesTags: ["Unit"]
+    }),
+    createUnit: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit`,
+        method: "POST",
+        body: queryArg.unit,
+        params: {
+          upstream_space_id: queryArg.upstreamSpaceId,
+          upstream_unit_id: queryArg.upstreamUnitId,
+          merge_external_source: queryArg.mergeExternalSource,
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    deleteUnit: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    getUnit: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}`,
+        params: {
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Unit"]
+    }),
+    patchUnit: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}`,
+        method: "PATCH",
+        body: queryArg.body,
+        params: {
+          revision_id: queryArg.revisionId,
+          dry_run: queryArg.dryRun,
+          upgrade: queryArg.upgrade,
+          restore: queryArg.restore,
+          resolve: queryArg.resolve,
+          merge_source: queryArg.mergeSource,
+          merge_base: queryArg.mergeBase,
+          merge_end: queryArg.mergeEnd,
+          merge_external_source: queryArg.mergeExternalSource,
+          merge_disable_subtraction: queryArg.mergeDisableSubtraction,
+          where_mutation: queryArg.whereMutation,
+          filter_mutation: queryArg.filterMutation,
+          tag: queryArg.tag,
+          change_set_id: queryArg.changeSetId,
+          subgroup: queryArg.subgroup
+        }
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    updateUnit: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}`,
+        method: "PUT",
+        body: queryArg.unit,
+        params: {
+          revision_id: queryArg.revisionId,
+          dry_run: queryArg.dryRun,
+          upgrade: queryArg.upgrade,
+          restore: queryArg.restore,
+          resolve: queryArg.resolve,
+          merge_source: queryArg.mergeSource,
+          merge_base: queryArg.mergeBase,
+          merge_end: queryArg.mergeEnd,
+          merge_external_source: queryArg.mergeExternalSource,
+          merge_disable_subtraction: queryArg.mergeDisableSubtraction,
+          where_mutation: queryArg.whereMutation,
+          filter_mutation: queryArg.filterMutation,
+          tag: queryArg.tag,
+          change_set_id: queryArg.changeSetId,
+          subgroup: queryArg.subgroup
+        }
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    applyUnit: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/apply`,
+        method: "POST",
+        params: {
+          revision: queryArg.revision,
+          dry_run: queryArg.dryRun,
+          drift_mode: queryArg.driftMode
+        }
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    approveUnit: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/approve`,
+        method: "POST",
+        params: {
+          revision: queryArg.revision
+        }
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    downloadUnitData: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/data`
+      }),
+      providesTags: ["Unit"]
+    }),
+    destroyUnit: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/destroy`,
+        method: "POST",
+        params: {
+          dry_run: queryArg.dryRun
+        }
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    getUnitExtended: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/extended`
+      }),
+      providesTags: ["Unit"]
+    }),
+    importUnit: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/import`,
+        method: "POST",
+        body: queryArg.importRequest,
+        params: {
+          dry_run: queryArg.dryRun
+        }
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    downloadUnitLiveData: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/live_data`
+      }),
+      providesTags: ["Unit"]
+    }),
+    downloadUnitLiveState: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/live_state`
+      }),
+      providesTags: ["Unit"]
+    }),
+    listExtendedMutations: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/mutation`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Mutation"]
+    }),
+    getExtendedMutation: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/mutation/${queryArg.mutationId}`,
+        params: {
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Mutation"]
+    }),
+    setUnitPredicates: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/predicates`,
+        method: "POST",
+        body: queryArg.unitPredicatesRequest
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    refreshUnit: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/refresh`,
+        method: "POST",
+        params: {
+          dry_run: queryArg.dryRun,
+          drift_mode: queryArg.driftMode
+        }
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    listExtendedRevisions: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/revision`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Revision"]
+    }),
+    getExtendedRevision: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/revision/${queryArg.revisionId}`,
+        params: {
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Revision"]
+    }),
+    downloadRevisionData: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/revision/${queryArg.revisionId}/data`
+      }),
+      providesTags: ["Revision"]
+    }),
+    listUnitActions: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/unit_action`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains
+        }
+      }),
+      providesTags: ["UnitAction"]
+    }),
+    getUnitAction: build.query(
+      {
+        query: (queryArg) => ({
+          url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/unit_action/${queryArg.unitActionId}`
+        }),
+        providesTags: ["UnitAction"]
+      }
+    ),
+    listUnitEvents: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/unit_event`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains
+        }
+      }),
+      providesTags: ["UnitEvent"]
+    }),
+    getUnitEvent: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/unit/${queryArg.unitId}/unit_event/${queryArg.unitEventId}`
+      }),
+      providesTags: ["UnitEvent"]
+    }),
+    listViews: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/view`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["View"]
+    }),
+    createView: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/view`,
+        method: "POST",
+        body: queryArg.view,
+        params: {
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["View"]
+    }),
+    deleteView: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/view/${queryArg.viewId}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: ["View"]
+    }),
+    getView: build.query({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/view/${queryArg.viewId}`,
+        params: {
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["View"]
+    }),
+    patchView: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/view/${queryArg.viewId}`,
+        method: "PATCH",
+        body: queryArg.body
+      }),
+      invalidatesTags: ["View"]
+    }),
+    updateView: build.mutation({
+      query: (queryArg) => ({
+        url: `/space/${queryArg.spaceId}/view/${queryArg.viewId}`,
+        method: "PUT",
+        body: queryArg.view
+      }),
+      invalidatesTags: ["View"]
+    }),
+    bulkDeleteTags: build.mutation({
+      query: (queryArg) => ({
+        url: `/tag`,
+        method: "DELETE",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["Tag"]
+    }),
+    listAllTags: build.query({
+      query: (queryArg) => ({
+        url: `/tag`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Tag"]
+    }),
+    bulkPatchTags: build.mutation({
+      query: (queryArg) => ({
+        url: `/tag`,
+        method: "PATCH",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["Tag"]
+    }),
+    bulkCreateTags: build.mutation({
+      query: (queryArg) => ({
+        url: `/tag`,
+        method: "POST",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          name_prefixes: queryArg.namePrefixes,
+          variant_labels: queryArg.variantLabels,
+          name_pattern: queryArg.namePattern,
+          where_space: queryArg.whereSpace,
+          filter_space: queryArg.filterSpace,
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["Tag"]
+    }),
+    bulkDeleteTargets: build.mutation({
+      query: (queryArg) => ({
+        url: `/target`,
+        method: "DELETE",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["Target"]
+    }),
+    listAllTargets: build.query({
+      query: (queryArg) => ({
+        url: `/target`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Target"]
+    }),
+    bulkPatchTargets: build.mutation({
+      query: (queryArg) => ({
+        url: `/target`,
+        method: "PATCH",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          refresh_triggers: queryArg.refreshTriggers
+        }
+      }),
+      invalidatesTags: ["Target"]
+    }),
+    bulkDeleteTriggers: build.mutation({
+      query: (queryArg) => ({
+        url: `/trigger`,
+        method: "DELETE",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["Trigger"]
+    }),
+    listAllTriggers: build.query({
+      query: (queryArg) => ({
+        url: `/trigger`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["Trigger"]
+    }),
+    bulkPatchTriggers: build.mutation({
+      query: (queryArg) => ({
+        url: `/trigger`,
+        method: "PATCH",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["Trigger"]
+    }),
+    bulkCreateTriggers: build.mutation({
+      query: (queryArg) => ({
+        url: `/trigger`,
+        method: "POST",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          name_prefixes: queryArg.namePrefixes,
+          where_space: queryArg.whereSpace,
+          filter_space: queryArg.filterSpace,
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["Trigger"]
+    }),
+    bulkDeleteUnits: build.mutation({
+      query: (queryArg) => ({
+        url: `/unit`,
+        method: "DELETE",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    listAllUnits: build.query({
+      query: (queryArg) => ({
+        url: `/unit`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select,
+          resource_type: queryArg.resourceType,
+          where_data: queryArg.whereData,
+          where_trigger: queryArg.whereTrigger,
+          trigger_filter: queryArg.triggerFilter,
+          triggers_passed: queryArg.triggersPassed,
+          view: queryArg.view
+        }
+      }),
+      providesTags: ["Unit"]
+    }),
+    bulkPatchUnits: build.mutation({
+      query: (queryArg) => ({
+        url: `/unit`,
+        method: "PATCH",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          dry_run: queryArg.dryRun,
+          upgrade: queryArg.upgrade,
+          restore: queryArg.restore,
+          resolve: queryArg.resolve,
+          merge_source: queryArg.mergeSource,
+          merge_base: queryArg.mergeBase,
+          merge_end: queryArg.mergeEnd,
+          merge_external_source: queryArg.mergeExternalSource,
+          merge_disable_subtraction: queryArg.mergeDisableSubtraction,
+          where_mutation: queryArg.whereMutation,
+          filter_mutation: queryArg.filterMutation,
+          tag: queryArg.tag,
+          change_set_id: queryArg.changeSetId,
+          subgroup: queryArg.subgroup
+        }
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    bulkCreateUnits: build.mutation({
+      query: (queryArg) => ({
+        url: `/unit`,
+        method: "POST",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          name_prefixes: queryArg.namePrefixes,
+          variant_labels: queryArg.variantLabels,
+          name_pattern: queryArg.namePattern,
+          where_space: queryArg.whereSpace,
+          filter_space: queryArg.filterSpace,
+          allow_exists: queryArg.allowExists,
+          include_outgoing_links_where: queryArg.includeOutgoingLinksWhere
+        }
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    bulkApplyUnits: build.mutation({
+      query: (queryArg) => ({
+        url: `/unit/apply`,
+        method: "POST",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          dry_run: queryArg.dryRun,
+          revision: queryArg.revision,
+          drift_mode: queryArg.driftMode
+        }
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    bulkApproveUnits: build.mutation({
+      query: (queryArg) => ({
+        url: `/unit/approve`,
+        method: "POST",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          revision: queryArg.revision
+        }
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    bulkCancelUnits: build.mutation({
+      query: (queryArg) => ({
+        url: `/unit/cancel`,
+        method: "POST",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    bulkDestroyUnits: build.mutation({
+      query: (queryArg) => ({
+        url: `/unit/destroy`,
+        method: "POST",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          dry_run: queryArg.dryRun
+        }
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    bulkRefreshUnits: build.mutation({
+      query: (queryArg) => ({
+        url: `/unit/refresh`,
+        method: "POST",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          dry_run: queryArg.dryRun,
+          drift_mode: queryArg.driftMode
+        }
+      }),
+      invalidatesTags: ["Unit"]
+    }),
+    bulkTagUnits: build.mutation(
+      {
+        query: (queryArg) => ({
+          url: `/unit/tag`,
+          method: "POST",
+          body: queryArg.unitTagRequest,
+          params: {
+            where: queryArg.where,
+            filter: queryArg.filter,
+            contains: queryArg.contains,
+            include: queryArg.include
+          }
+        }),
+        invalidatesTags: ["Unit"]
+      }
+    ),
+    listAllUnitActions: build.query({
+      query: (queryArg) => ({
+        url: `/unit_action`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains
+        }
+      }),
+      providesTags: ["QueuedOperation"]
+    }),
+    listAllUnitEvents: build.query({
+      query: (queryArg) => ({
+        url: `/unit_event`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains
+        }
+      }),
+      providesTags: ["UnitEvent"]
+    }),
+    listUsers: build.query({
+      query: (queryArg) => ({
+        url: `/user`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains
+        }
+      }),
+      providesTags: ["User"]
+    }),
+    getUser: build.query({
+      query: (queryArg) => ({ url: `/user/${queryArg.userId}` }),
+      providesTags: ["User"]
+    }),
+    bulkDeleteViews: build.mutation({
+      query: (queryArg) => ({
+        url: `/view`,
+        method: "DELETE",
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["View"]
+    }),
+    listAllViews: build.query({
+      query: (queryArg) => ({
+        url: `/view`,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          select: queryArg.select
+        }
+      }),
+      providesTags: ["View"]
+    }),
+    bulkPatchViews: build.mutation({
+      query: (queryArg) => ({
+        url: `/view`,
+        method: "PATCH",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include
+        }
+      }),
+      invalidatesTags: ["View"]
+    }),
+    bulkCreateViews: build.mutation({
+      query: (queryArg) => ({
+        url: `/view`,
+        method: "POST",
+        body: queryArg.body,
+        params: {
+          where: queryArg.where,
+          filter: queryArg.filter,
+          contains: queryArg.contains,
+          include: queryArg.include,
+          name_prefixes: queryArg.namePrefixes,
+          variant_labels: queryArg.variantLabels,
+          name_pattern: queryArg.namePattern,
+          where_space: queryArg.whereSpace,
+          filter_space: queryArg.filterSpace,
+          allow_exists: queryArg.allowExists
+        }
+      }),
+      invalidatesTags: ["View"]
+    })
+  }),
+  overrideExisting: false
+});
+var {
+  useBulkDeleteSpacesMutation,
+  useBulkPatchSpacesMutation,
+  useBulkCreateSpacesMutation,
+  useBulkDeleteAttributesMutation,
+  useListAllAttributesQuery,
+  useLazyListAllAttributesQuery,
+  useBulkPatchAttributesMutation,
+  useBulkCreateAttributesMutation,
+  useBulkDeleteBridgeWorkersMutation,
+  useListAllBridgeWorkersQuery,
+  useLazyListAllBridgeWorkersQuery,
+  useBulkPatchBridgeWorkersMutation,
+  useCreateActionResultMutation,
+  useGetSelfQuery,
+  useLazyGetSelfQuery,
+  useListQueuedOperationsQuery,
+  useLazyListQueuedOperationsQuery,
+  useGetQueuedOperationQuery,
+  useLazyGetQueuedOperationQuery,
+  useStreamBridgeWorkerMutation,
+  useUserCreateActionResultMutation,
+  useBulkDeleteChangeSetsMutation,
+  useListAllChangeSetsQuery,
+  useLazyListAllChangeSetsQuery,
+  useBulkPatchChangeSetsMutation,
+  useBulkCreateChangeSetsMutation,
+  useBulkDeleteFiltersMutation,
+  useListAllFiltersQuery,
+  useLazyListAllFiltersQuery,
+  useBulkPatchFiltersMutation,
+  useBulkCreateFiltersMutation,
+  useListOrgFunctionsQuery,
+  useLazyListOrgFunctionsQuery,
+  useInvokeFunctionsOnOrgMutation,
+  useApiInfoQuery,
+  useLazyApiInfoQuery,
+  useBulkDeleteInvocationsMutation,
+  useListAllInvocationsQuery,
+  useLazyListAllInvocationsQuery,
+  useBulkPatchInvocationsMutation,
+  useBulkCreateInvocationsMutation,
+  useBulkDeleteLinksMutation,
+  useSearchListLinksQuery,
+  useLazySearchListLinksQuery,
+  useBulkPatchLinksMutation,
+  useBulkCreateLinksMutation,
+  useGetMeQuery,
+  useLazyGetMeQuery,
+  useListOAuthClientsQuery,
+  useLazyListOAuthClientsQuery,
+  useCreateOAuthClientMutation,
+  useDeleteOAuthClientMutation,
+  useGetOAuthClientQuery,
+  useLazyGetOAuthClientQuery,
+  useListOrganizationsQuery,
+  useLazyListOrganizationsQuery,
+  useCreateOrganizationMutation,
+  useDeleteOrganizationMutation,
+  useGetOrganizationQuery,
+  useLazyGetOrganizationQuery,
+  useUpdateOrganizationMutation,
+  useListOrganizationMembersQuery,
+  useLazyListOrganizationMembersQuery,
+  useCreateOrganizationMemberMutation,
+  useDeleteOrganizationMemberMutation,
+  useGetOrganizationMemberQuery,
+  useLazyGetOrganizationMemberQuery,
+  useListAllReleasesQuery,
+  useLazyListAllReleasesQuery,
+  useListAllRevisionsQuery,
+  useLazyListAllRevisionsQuery,
+  useListSpacesQuery,
+  useLazyListSpacesQuery,
+  useCreateSpaceMutation,
+  useDeleteSpaceMutation,
+  useGetSpaceQuery,
+  useLazyGetSpaceQuery,
+  usePatchSpaceMutation,
+  useUpdateSpaceMutation,
+  useListAttributesQuery,
+  useLazyListAttributesQuery,
+  useCreateAttributeMutation,
+  useDeleteAttributeMutation,
+  useGetAttributeQuery,
+  useLazyGetAttributeQuery,
+  usePatchAttributeMutation,
+  useUpdateAttributeMutation,
+  useListBridgeWorkersQuery,
+  useLazyListBridgeWorkersQuery,
+  useCreateBridgeWorkerMutation,
+  useDeleteBridgeWorkerMutation,
+  useGetBridgeWorkerQuery,
+  useLazyGetBridgeWorkerQuery,
+  usePatchBridgeWorkerMutation,
+  useUpdateBridgeWorkerMutation,
+  useListBridgeWorkerFunctionsQuery,
+  useLazyListBridgeWorkerFunctionsQuery,
+  useListBridgeWorkerStatusesQuery,
+  useLazyListBridgeWorkerStatusesQuery,
+  useGetBridgeWorkerStatusQuery,
+  useLazyGetBridgeWorkerStatusQuery,
+  useListChangeSetsQuery,
+  useLazyListChangeSetsQuery,
+  useCreateChangeSetMutation,
+  useDeleteChangeSetMutation,
+  useGetChangeSetQuery,
+  useLazyGetChangeSetQuery,
+  usePatchChangeSetMutation,
+  useUpdateChangeSetMutation,
+  useListFiltersQuery,
+  useLazyListFiltersQuery,
+  useCreateFilterMutation,
+  useDeleteFilterMutation,
+  useGetFilterQuery,
+  useLazyGetFilterQuery,
+  usePatchFilterMutation,
+  useUpdateFilterMutation,
+  useListFunctionsQuery,
+  useLazyListFunctionsQuery,
+  useInvokeFunctionsMutation,
+  useListInvocationsQuery,
+  useLazyListInvocationsQuery,
+  useCreateInvocationMutation,
+  useDeleteInvocationMutation,
+  useGetInvocationQuery,
+  useLazyGetInvocationQuery,
+  usePatchInvocationMutation,
+  useUpdateInvocationMutation,
+  useListLinksQuery,
+  useLazyListLinksQuery,
+  useCreateLinkMutation,
+  useDeleteLinkMutation,
+  useGetLinkQuery,
+  useLazyGetLinkQuery,
+  usePatchLinkMutation,
+  useUpdateLinkMutation,
+  useListExtendedReleasesQuery,
+  useLazyListExtendedReleasesQuery,
+  usePublishReleaseMutation,
+  useWithdrawReleaseMutation,
+  useGetExtendedReleaseQuery,
+  useLazyGetExtendedReleaseQuery,
+  useListTagsQuery,
+  useLazyListTagsQuery,
+  useCreateTagMutation,
+  useDeleteTagMutation,
+  useGetTagQuery,
+  useLazyGetTagQuery,
+  usePatchTagMutation,
+  useUpdateTagMutation,
+  useListTargetsQuery,
+  useLazyListTargetsQuery,
+  useCreateTargetMutation,
+  useDeleteTargetMutation,
+  useGetTargetQuery,
+  useLazyGetTargetQuery,
+  usePatchTargetMutation,
+  useUpdateTargetMutation,
+  useListTriggersQuery,
+  useLazyListTriggersQuery,
+  useCreateTriggerMutation,
+  useDeleteTriggerMutation,
+  useGetTriggerQuery,
+  useLazyGetTriggerQuery,
+  usePatchTriggerMutation,
+  useUpdateTriggerMutation,
+  useListUnitsQuery,
+  useLazyListUnitsQuery,
+  useCreateUnitMutation,
+  useDeleteUnitMutation,
+  useGetUnitQuery,
+  useLazyGetUnitQuery,
+  usePatchUnitMutation,
+  useUpdateUnitMutation,
+  useApplyUnitMutation,
+  useApproveUnitMutation,
+  useDownloadUnitDataQuery,
+  useLazyDownloadUnitDataQuery,
+  useDestroyUnitMutation,
+  useGetUnitExtendedQuery,
+  useLazyGetUnitExtendedQuery,
+  useImportUnitMutation,
+  useDownloadUnitLiveDataQuery,
+  useLazyDownloadUnitLiveDataQuery,
+  useDownloadUnitLiveStateQuery,
+  useLazyDownloadUnitLiveStateQuery,
+  useListExtendedMutationsQuery,
+  useLazyListExtendedMutationsQuery,
+  useGetExtendedMutationQuery,
+  useLazyGetExtendedMutationQuery,
+  useSetUnitPredicatesMutation,
+  useRefreshUnitMutation,
+  useListExtendedRevisionsQuery,
+  useLazyListExtendedRevisionsQuery,
+  useGetExtendedRevisionQuery,
+  useLazyGetExtendedRevisionQuery,
+  useDownloadRevisionDataQuery,
+  useLazyDownloadRevisionDataQuery,
+  useListUnitActionsQuery,
+  useLazyListUnitActionsQuery,
+  useGetUnitActionQuery,
+  useLazyGetUnitActionQuery,
+  useListUnitEventsQuery,
+  useLazyListUnitEventsQuery,
+  useGetUnitEventQuery,
+  useLazyGetUnitEventQuery,
+  useListViewsQuery,
+  useLazyListViewsQuery,
+  useCreateViewMutation,
+  useDeleteViewMutation,
+  useGetViewQuery,
+  useLazyGetViewQuery,
+  usePatchViewMutation,
+  useUpdateViewMutation,
+  useBulkDeleteTagsMutation,
+  useListAllTagsQuery,
+  useLazyListAllTagsQuery,
+  useBulkPatchTagsMutation,
+  useBulkCreateTagsMutation,
+  useBulkDeleteTargetsMutation,
+  useListAllTargetsQuery,
+  useLazyListAllTargetsQuery,
+  useBulkPatchTargetsMutation,
+  useBulkDeleteTriggersMutation,
+  useListAllTriggersQuery,
+  useLazyListAllTriggersQuery,
+  useBulkPatchTriggersMutation,
+  useBulkCreateTriggersMutation,
+  useBulkDeleteUnitsMutation,
+  useListAllUnitsQuery,
+  useLazyListAllUnitsQuery,
+  useBulkPatchUnitsMutation,
+  useBulkCreateUnitsMutation,
+  useBulkApplyUnitsMutation,
+  useBulkApproveUnitsMutation,
+  useBulkCancelUnitsMutation,
+  useBulkDestroyUnitsMutation,
+  useBulkRefreshUnitsMutation,
+  useBulkTagUnitsMutation,
+  useListAllUnitActionsQuery,
+  useLazyListAllUnitActionsQuery,
+  useListAllUnitEventsQuery,
+  useLazyListAllUnitEventsQuery,
+  useListUsersQuery,
+  useLazyListUsersQuery,
+  useGetUserQuery,
+  useLazyGetUserQuery,
+  useBulkDeleteViewsMutation,
+  useListAllViewsQuery,
+  useLazyListAllViewsQuery,
+  useBulkPatchViewsMutation,
+  useBulkCreateViewsMutation
+} = injectedRtkApi;
+exports.addTagTypes = addTagTypes;
+exports.confighubApi = injectedRtkApi;
+exports.configureConfigHub = configureConfigHub;
+exports.useApiInfoQuery = useApiInfoQuery;
+exports.useApplyUnitMutation = useApplyUnitMutation;
+exports.useApproveUnitMutation = useApproveUnitMutation;
+exports.useBulkApplyUnitsMutation = useBulkApplyUnitsMutation;
+exports.useBulkApproveUnitsMutation = useBulkApproveUnitsMutation;
+exports.useBulkCancelUnitsMutation = useBulkCancelUnitsMutation;
+exports.useBulkCreateAttributesMutation = useBulkCreateAttributesMutation;
+exports.useBulkCreateChangeSetsMutation = useBulkCreateChangeSetsMutation;
+exports.useBulkCreateFiltersMutation = useBulkCreateFiltersMutation;
+exports.useBulkCreateInvocationsMutation = useBulkCreateInvocationsMutation;
+exports.useBulkCreateLinksMutation = useBulkCreateLinksMutation;
+exports.useBulkCreateSpacesMutation = useBulkCreateSpacesMutation;
+exports.useBulkCreateTagsMutation = useBulkCreateTagsMutation;
+exports.useBulkCreateTriggersMutation = useBulkCreateTriggersMutation;
+exports.useBulkCreateUnitsMutation = useBulkCreateUnitsMutation;
+exports.useBulkCreateViewsMutation = useBulkCreateViewsMutation;
+exports.useBulkDeleteAttributesMutation = useBulkDeleteAttributesMutation;
+exports.useBulkDeleteBridgeWorkersMutation = useBulkDeleteBridgeWorkersMutation;
+exports.useBulkDeleteChangeSetsMutation = useBulkDeleteChangeSetsMutation;
+exports.useBulkDeleteFiltersMutation = useBulkDeleteFiltersMutation;
+exports.useBulkDeleteInvocationsMutation = useBulkDeleteInvocationsMutation;
+exports.useBulkDeleteLinksMutation = useBulkDeleteLinksMutation;
+exports.useBulkDeleteSpacesMutation = useBulkDeleteSpacesMutation;
+exports.useBulkDeleteTagsMutation = useBulkDeleteTagsMutation;
+exports.useBulkDeleteTargetsMutation = useBulkDeleteTargetsMutation;
+exports.useBulkDeleteTriggersMutation = useBulkDeleteTriggersMutation;
+exports.useBulkDeleteUnitsMutation = useBulkDeleteUnitsMutation;
+exports.useBulkDeleteViewsMutation = useBulkDeleteViewsMutation;
+exports.useBulkDestroyUnitsMutation = useBulkDestroyUnitsMutation;
+exports.useBulkPatchAttributesMutation = useBulkPatchAttributesMutation;
+exports.useBulkPatchBridgeWorkersMutation = useBulkPatchBridgeWorkersMutation;
+exports.useBulkPatchChangeSetsMutation = useBulkPatchChangeSetsMutation;
+exports.useBulkPatchFiltersMutation = useBulkPatchFiltersMutation;
+exports.useBulkPatchInvocationsMutation = useBulkPatchInvocationsMutation;
+exports.useBulkPatchLinksMutation = useBulkPatchLinksMutation;
+exports.useBulkPatchSpacesMutation = useBulkPatchSpacesMutation;
+exports.useBulkPatchTagsMutation = useBulkPatchTagsMutation;
+exports.useBulkPatchTargetsMutation = useBulkPatchTargetsMutation;
+exports.useBulkPatchTriggersMutation = useBulkPatchTriggersMutation;
+exports.useBulkPatchUnitsMutation = useBulkPatchUnitsMutation;
+exports.useBulkPatchViewsMutation = useBulkPatchViewsMutation;
+exports.useBulkRefreshUnitsMutation = useBulkRefreshUnitsMutation;
+exports.useBulkTagUnitsMutation = useBulkTagUnitsMutation;
+exports.useCreateActionResultMutation = useCreateActionResultMutation;
+exports.useCreateAttributeMutation = useCreateAttributeMutation;
+exports.useCreateBridgeWorkerMutation = useCreateBridgeWorkerMutation;
+exports.useCreateChangeSetMutation = useCreateChangeSetMutation;
+exports.useCreateFilterMutation = useCreateFilterMutation;
+exports.useCreateInvocationMutation = useCreateInvocationMutation;
+exports.useCreateLinkMutation = useCreateLinkMutation;
+exports.useCreateOAuthClientMutation = useCreateOAuthClientMutation;
+exports.useCreateOrganizationMemberMutation = useCreateOrganizationMemberMutation;
+exports.useCreateOrganizationMutation = useCreateOrganizationMutation;
+exports.useCreateSpaceMutation = useCreateSpaceMutation;
+exports.useCreateTagMutation = useCreateTagMutation;
+exports.useCreateTargetMutation = useCreateTargetMutation;
+exports.useCreateTriggerMutation = useCreateTriggerMutation;
+exports.useCreateUnitMutation = useCreateUnitMutation;
+exports.useCreateViewMutation = useCreateViewMutation;
+exports.useDeleteAttributeMutation = useDeleteAttributeMutation;
+exports.useDeleteBridgeWorkerMutation = useDeleteBridgeWorkerMutation;
+exports.useDeleteChangeSetMutation = useDeleteChangeSetMutation;
+exports.useDeleteFilterMutation = useDeleteFilterMutation;
+exports.useDeleteInvocationMutation = useDeleteInvocationMutation;
+exports.useDeleteLinkMutation = useDeleteLinkMutation;
+exports.useDeleteOAuthClientMutation = useDeleteOAuthClientMutation;
+exports.useDeleteOrganizationMemberMutation = useDeleteOrganizationMemberMutation;
+exports.useDeleteOrganizationMutation = useDeleteOrganizationMutation;
+exports.useDeleteSpaceMutation = useDeleteSpaceMutation;
+exports.useDeleteTagMutation = useDeleteTagMutation;
+exports.useDeleteTargetMutation = useDeleteTargetMutation;
+exports.useDeleteTriggerMutation = useDeleteTriggerMutation;
+exports.useDeleteUnitMutation = useDeleteUnitMutation;
+exports.useDeleteViewMutation = useDeleteViewMutation;
+exports.useDestroyUnitMutation = useDestroyUnitMutation;
+exports.useDownloadRevisionDataQuery = useDownloadRevisionDataQuery;
+exports.useDownloadUnitDataQuery = useDownloadUnitDataQuery;
+exports.useDownloadUnitLiveDataQuery = useDownloadUnitLiveDataQuery;
+exports.useDownloadUnitLiveStateQuery = useDownloadUnitLiveStateQuery;
+exports.useGetAttributeQuery = useGetAttributeQuery;
+exports.useGetBridgeWorkerQuery = useGetBridgeWorkerQuery;
+exports.useGetBridgeWorkerStatusQuery = useGetBridgeWorkerStatusQuery;
+exports.useGetChangeSetQuery = useGetChangeSetQuery;
+exports.useGetExtendedMutationQuery = useGetExtendedMutationQuery;
+exports.useGetExtendedReleaseQuery = useGetExtendedReleaseQuery;
+exports.useGetExtendedRevisionQuery = useGetExtendedRevisionQuery;
+exports.useGetFilterQuery = useGetFilterQuery;
+exports.useGetInvocationQuery = useGetInvocationQuery;
+exports.useGetLinkQuery = useGetLinkQuery;
+exports.useGetMeQuery = useGetMeQuery;
+exports.useGetOAuthClientQuery = useGetOAuthClientQuery;
+exports.useGetOrganizationMemberQuery = useGetOrganizationMemberQuery;
+exports.useGetOrganizationQuery = useGetOrganizationQuery;
+exports.useGetQueuedOperationQuery = useGetQueuedOperationQuery;
+exports.useGetSelfQuery = useGetSelfQuery;
+exports.useGetSpaceQuery = useGetSpaceQuery;
+exports.useGetTagQuery = useGetTagQuery;
+exports.useGetTargetQuery = useGetTargetQuery;
+exports.useGetTriggerQuery = useGetTriggerQuery;
+exports.useGetUnitActionQuery = useGetUnitActionQuery;
+exports.useGetUnitEventQuery = useGetUnitEventQuery;
+exports.useGetUnitExtendedQuery = useGetUnitExtendedQuery;
+exports.useGetUnitQuery = useGetUnitQuery;
+exports.useGetUserQuery = useGetUserQuery;
+exports.useGetViewQuery = useGetViewQuery;
+exports.useImportUnitMutation = useImportUnitMutation;
+exports.useInvokeFunctionsMutation = useInvokeFunctionsMutation;
+exports.useInvokeFunctionsOnOrgMutation = useInvokeFunctionsOnOrgMutation;
+exports.useLazyApiInfoQuery = useLazyApiInfoQuery;
+exports.useLazyDownloadRevisionDataQuery = useLazyDownloadRevisionDataQuery;
+exports.useLazyDownloadUnitDataQuery = useLazyDownloadUnitDataQuery;
+exports.useLazyDownloadUnitLiveDataQuery = useLazyDownloadUnitLiveDataQuery;
+exports.useLazyDownloadUnitLiveStateQuery = useLazyDownloadUnitLiveStateQuery;
+exports.useLazyGetAttributeQuery = useLazyGetAttributeQuery;
+exports.useLazyGetBridgeWorkerQuery = useLazyGetBridgeWorkerQuery;
+exports.useLazyGetBridgeWorkerStatusQuery = useLazyGetBridgeWorkerStatusQuery;
+exports.useLazyGetChangeSetQuery = useLazyGetChangeSetQuery;
+exports.useLazyGetExtendedMutationQuery = useLazyGetExtendedMutationQuery;
+exports.useLazyGetExtendedReleaseQuery = useLazyGetExtendedReleaseQuery;
+exports.useLazyGetExtendedRevisionQuery = useLazyGetExtendedRevisionQuery;
+exports.useLazyGetFilterQuery = useLazyGetFilterQuery;
+exports.useLazyGetInvocationQuery = useLazyGetInvocationQuery;
+exports.useLazyGetLinkQuery = useLazyGetLinkQuery;
+exports.useLazyGetMeQuery = useLazyGetMeQuery;
+exports.useLazyGetOAuthClientQuery = useLazyGetOAuthClientQuery;
+exports.useLazyGetOrganizationMemberQuery = useLazyGetOrganizationMemberQuery;
+exports.useLazyGetOrganizationQuery = useLazyGetOrganizationQuery;
+exports.useLazyGetQueuedOperationQuery = useLazyGetQueuedOperationQuery;
+exports.useLazyGetSelfQuery = useLazyGetSelfQuery;
+exports.useLazyGetSpaceQuery = useLazyGetSpaceQuery;
+exports.useLazyGetTagQuery = useLazyGetTagQuery;
+exports.useLazyGetTargetQuery = useLazyGetTargetQuery;
+exports.useLazyGetTriggerQuery = useLazyGetTriggerQuery;
+exports.useLazyGetUnitActionQuery = useLazyGetUnitActionQuery;
+exports.useLazyGetUnitEventQuery = useLazyGetUnitEventQuery;
+exports.useLazyGetUnitExtendedQuery = useLazyGetUnitExtendedQuery;
+exports.useLazyGetUnitQuery = useLazyGetUnitQuery;
+exports.useLazyGetUserQuery = useLazyGetUserQuery;
+exports.useLazyGetViewQuery = useLazyGetViewQuery;
+exports.useLazyListAllAttributesQuery = useLazyListAllAttributesQuery;
+exports.useLazyListAllBridgeWorkersQuery = useLazyListAllBridgeWorkersQuery;
+exports.useLazyListAllChangeSetsQuery = useLazyListAllChangeSetsQuery;
+exports.useLazyListAllFiltersQuery = useLazyListAllFiltersQuery;
+exports.useLazyListAllInvocationsQuery = useLazyListAllInvocationsQuery;
+exports.useLazyListAllReleasesQuery = useLazyListAllReleasesQuery;
+exports.useLazyListAllRevisionsQuery = useLazyListAllRevisionsQuery;
+exports.useLazyListAllTagsQuery = useLazyListAllTagsQuery;
+exports.useLazyListAllTargetsQuery = useLazyListAllTargetsQuery;
+exports.useLazyListAllTriggersQuery = useLazyListAllTriggersQuery;
+exports.useLazyListAllUnitActionsQuery = useLazyListAllUnitActionsQuery;
+exports.useLazyListAllUnitEventsQuery = useLazyListAllUnitEventsQuery;
+exports.useLazyListAllUnitsQuery = useLazyListAllUnitsQuery;
+exports.useLazyListAllViewsQuery = useLazyListAllViewsQuery;
+exports.useLazyListAttributesQuery = useLazyListAttributesQuery;
+exports.useLazyListBridgeWorkerFunctionsQuery = useLazyListBridgeWorkerFunctionsQuery;
+exports.useLazyListBridgeWorkerStatusesQuery = useLazyListBridgeWorkerStatusesQuery;
+exports.useLazyListBridgeWorkersQuery = useLazyListBridgeWorkersQuery;
+exports.useLazyListChangeSetsQuery = useLazyListChangeSetsQuery;
+exports.useLazyListExtendedMutationsQuery = useLazyListExtendedMutationsQuery;
+exports.useLazyListExtendedReleasesQuery = useLazyListExtendedReleasesQuery;
+exports.useLazyListExtendedRevisionsQuery = useLazyListExtendedRevisionsQuery;
+exports.useLazyListFiltersQuery = useLazyListFiltersQuery;
+exports.useLazyListFunctionsQuery = useLazyListFunctionsQuery;
+exports.useLazyListInvocationsQuery = useLazyListInvocationsQuery;
+exports.useLazyListLinksQuery = useLazyListLinksQuery;
+exports.useLazyListOAuthClientsQuery = useLazyListOAuthClientsQuery;
+exports.useLazyListOrgFunctionsQuery = useLazyListOrgFunctionsQuery;
+exports.useLazyListOrganizationMembersQuery = useLazyListOrganizationMembersQuery;
+exports.useLazyListOrganizationsQuery = useLazyListOrganizationsQuery;
+exports.useLazyListQueuedOperationsQuery = useLazyListQueuedOperationsQuery;
+exports.useLazyListSpacesQuery = useLazyListSpacesQuery;
+exports.useLazyListTagsQuery = useLazyListTagsQuery;
+exports.useLazyListTargetsQuery = useLazyListTargetsQuery;
+exports.useLazyListTriggersQuery = useLazyListTriggersQuery;
+exports.useLazyListUnitActionsQuery = useLazyListUnitActionsQuery;
+exports.useLazyListUnitEventsQuery = useLazyListUnitEventsQuery;
+exports.useLazyListUnitsQuery = useLazyListUnitsQuery;
+exports.useLazyListUsersQuery = useLazyListUsersQuery;
+exports.useLazyListViewsQuery = useLazyListViewsQuery;
+exports.useLazySearchListLinksQuery = useLazySearchListLinksQuery;
+exports.useListAllAttributesQuery = useListAllAttributesQuery;
+exports.useListAllBridgeWorkersQuery = useListAllBridgeWorkersQuery;
+exports.useListAllChangeSetsQuery = useListAllChangeSetsQuery;
+exports.useListAllFiltersQuery = useListAllFiltersQuery;
+exports.useListAllInvocationsQuery = useListAllInvocationsQuery;
+exports.useListAllReleasesQuery = useListAllReleasesQuery;
+exports.useListAllRevisionsQuery = useListAllRevisionsQuery;
+exports.useListAllTagsQuery = useListAllTagsQuery;
+exports.useListAllTargetsQuery = useListAllTargetsQuery;
+exports.useListAllTriggersQuery = useListAllTriggersQuery;
+exports.useListAllUnitActionsQuery = useListAllUnitActionsQuery;
+exports.useListAllUnitEventsQuery = useListAllUnitEventsQuery;
+exports.useListAllUnitsQuery = useListAllUnitsQuery;
+exports.useListAllViewsQuery = useListAllViewsQuery;
+exports.useListAttributesQuery = useListAttributesQuery;
+exports.useListBridgeWorkerFunctionsQuery = useListBridgeWorkerFunctionsQuery;
+exports.useListBridgeWorkerStatusesQuery = useListBridgeWorkerStatusesQuery;
+exports.useListBridgeWorkersQuery = useListBridgeWorkersQuery;
+exports.useListChangeSetsQuery = useListChangeSetsQuery;
+exports.useListExtendedMutationsQuery = useListExtendedMutationsQuery;
+exports.useListExtendedReleasesQuery = useListExtendedReleasesQuery;
+exports.useListExtendedRevisionsQuery = useListExtendedRevisionsQuery;
+exports.useListFiltersQuery = useListFiltersQuery;
+exports.useListFunctionsQuery = useListFunctionsQuery;
+exports.useListInvocationsQuery = useListInvocationsQuery;
+exports.useListLinksQuery = useListLinksQuery;
+exports.useListOAuthClientsQuery = useListOAuthClientsQuery;
+exports.useListOrgFunctionsQuery = useListOrgFunctionsQuery;
+exports.useListOrganizationMembersQuery = useListOrganizationMembersQuery;
+exports.useListOrganizationsQuery = useListOrganizationsQuery;
+exports.useListQueuedOperationsQuery = useListQueuedOperationsQuery;
+exports.useListSpacesQuery = useListSpacesQuery;
+exports.useListTagsQuery = useListTagsQuery;
+exports.useListTargetsQuery = useListTargetsQuery;
+exports.useListTriggersQuery = useListTriggersQuery;
+exports.useListUnitActionsQuery = useListUnitActionsQuery;
+exports.useListUnitEventsQuery = useListUnitEventsQuery;
+exports.useListUnitsQuery = useListUnitsQuery;
+exports.useListUsersQuery = useListUsersQuery;
+exports.useListViewsQuery = useListViewsQuery;
+exports.usePatchAttributeMutation = usePatchAttributeMutation;
+exports.usePatchBridgeWorkerMutation = usePatchBridgeWorkerMutation;
+exports.usePatchChangeSetMutation = usePatchChangeSetMutation;
+exports.usePatchFilterMutation = usePatchFilterMutation;
+exports.usePatchInvocationMutation = usePatchInvocationMutation;
+exports.usePatchLinkMutation = usePatchLinkMutation;
+exports.usePatchSpaceMutation = usePatchSpaceMutation;
+exports.usePatchTagMutation = usePatchTagMutation;
+exports.usePatchTargetMutation = usePatchTargetMutation;
+exports.usePatchTriggerMutation = usePatchTriggerMutation;
+exports.usePatchUnitMutation = usePatchUnitMutation;
+exports.usePatchViewMutation = usePatchViewMutation;
+exports.usePublishReleaseMutation = usePublishReleaseMutation;
+exports.useRefreshUnitMutation = useRefreshUnitMutation;
+exports.useSearchListLinksQuery = useSearchListLinksQuery;
+exports.useSetUnitPredicatesMutation = useSetUnitPredicatesMutation;
+exports.useStreamBridgeWorkerMutation = useStreamBridgeWorkerMutation;
+exports.useUpdateAttributeMutation = useUpdateAttributeMutation;
+exports.useUpdateBridgeWorkerMutation = useUpdateBridgeWorkerMutation;
+exports.useUpdateChangeSetMutation = useUpdateChangeSetMutation;
+exports.useUpdateFilterMutation = useUpdateFilterMutation;
+exports.useUpdateInvocationMutation = useUpdateInvocationMutation;
+exports.useUpdateLinkMutation = useUpdateLinkMutation;
+exports.useUpdateOrganizationMutation = useUpdateOrganizationMutation;
+exports.useUpdateSpaceMutation = useUpdateSpaceMutation;
+exports.useUpdateTagMutation = useUpdateTagMutation;
+exports.useUpdateTargetMutation = useUpdateTargetMutation;
+exports.useUpdateTriggerMutation = useUpdateTriggerMutation;
+exports.useUpdateUnitMutation = useUpdateUnitMutation;
+exports.useUpdateViewMutation = useUpdateViewMutation;
+exports.useUserCreateActionResultMutation = useUserCreateActionResultMutation;
+exports.useWithdrawReleaseMutation = useWithdrawReleaseMutation;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map