@camunda/ccma-api 2.1.0 → 2.2.0

package/dist/services/control/control.annotations.service.js

@@ -0,0 +1,193 @@
+import { request } from "../../utils/api.js";
+import { HttpError } from "../../utils/errors.js";
+const BASE = { id: "control" };
+function contextFor(name, url, normalizedUrl, type, source) {
+  return {
+    method: {
+      name: `ControlAnnotationsService.${name}`,
+      url,
+      normalizedUrl,
+      type
+    },
+    source,
+    target: { name: "control", type: "internal" }
+  };
+}
+function queryOf(params = {}) {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0) {
+      query.set(key, String(value));
+    }
+  }
+  return query.size > 0 ? `?${query.toString()}` : "";
+}
+class ControlAnnotationsService {
+  /**
+   * Every live note and tag of one entity.
+   *
+   * An entity that carries nothing answers with two empty lists, and never
+   * 404. The call also answers for an entity that the fleet no longer holds,
+   * which is what keeps a link out of a search result working.
+   */
+  static async forEntity(params) {
+    const url = `api/annotations${queryOf(params.params)}`;
+    return ControlAnnotationsService.send(
+      params,
+      "forEntity",
+      url,
+      "api/annotations",
+      "get"
+    );
+  }
+  /**
+   * The tags, the note count and the newest note of many entities.
+   *
+   * A POST, because thousands of ids do not fit a request line. The answer
+   * holds only the entities that carry something.
+   */
+  static async lookup(params) {
+    return ControlAnnotationsService.send(
+      params,
+      "lookup",
+      "api/annotations/lookup",
+      "api/annotations/lookup",
+      "post",
+      params.params
+    );
+  }
+  /** Writes a note on an entity. Any signed-in Camundi can. */
+  static async addNote(params) {
+    const { annotation } = await ControlAnnotationsService.send(
+      params,
+      "addNote",
+      "api/annotations/notes",
+      "api/annotations/notes",
+      "post",
+      params.params
+    );
+    return annotation;
+  }
+  /** Changes the text of a note. Only the person who wrote it can. */
+  static async editNote(params) {
+    const url = `api/annotations/notes/${params.params.id}`;
+    const { annotation } = await ControlAnnotationsService.send(params, "editNote", url, "api/annotations/notes/:id", "patch", {
+      body: params.params.body,
+      version: params.params.version
+    });
+    return annotation;
+  }
+  /**
+   * Takes a note or a tag off an entity.
+   *
+   * The row stays: the removal is a soft delete, so who wrote it and who took
+   * it off both stay readable. A note can only be removed by its author; a tag
+   * can be removed by anybody.
+   */
+  static async remove(params) {
+    const url = `api/annotations/${params.params.id}`;
+    await ControlAnnotationsService.send(
+      params,
+      "remove",
+      url,
+      "api/annotations/:id",
+      "delete"
+    );
+  }
+  /**
+   * Attaches a tag to an entity, and adds it to the dictionary when it is new.
+   *
+   * The name is normalized by the backend, so `Partner` and `partner` reach
+   * one tag. A second attach of one tag on one entity answers 409.
+   */
+  static async addTag(params) {
+    const { annotation } = await ControlAnnotationsService.send(
+      params,
+      "addTag",
+      "api/annotations/tags",
+      "api/annotations/tags",
+      "post",
+      params.params
+    );
+    return annotation;
+  }
+  /**
+   * The tag dictionary, with the live entities of each tag counted, most used
+   * first.
+   *
+   * The autocomplete of the tag field reads this. It is what stops one idea
+   * from becoming three spellings.
+   *
+   * It answers one PAGE, because the dictionary only grows. Read `page.hasMore`
+   * to learn whether another follows.
+   */
+  static async listTags(params) {
+    const url = `api/annotations/tags${queryOf(params.params)}`;
+    return ControlAnnotationsService.send(
+      params,
+      "listTags",
+      url,
+      "api/annotations/tags",
+      "get"
+    );
+  }
+  /**
+   * One page of the annotations that match, newest first.
+   *
+   * The answer holds annotations of entities that no longer exist, which is
+   * the point: the note about a deleted cluster is often the only record of
+   * why it was there.
+   */
+  static async search(params) {
+    const url = `api/annotations/search${queryOf(params.params)}`;
+    return ControlAnnotationsService.send(
+      params,
+      "search",
+      url,
+      "api/annotations/search",
+      "get"
+    );
+  }
+  /**
+   * The shared half of every call above.
+   *
+   * Seven routes differ only in the verb, the path and the body. One private
+   * helper keeps the metrics context and the status check in one place.
+   */
+  static async send(params, name, url, normalizedUrl, method, body) {
+    const serviceContext = contextFor(
+      name,
+      url,
+      normalizedUrl,
+      method,
+      params.config.metrics?.source || "unset"
+    );
+    const response = await request({
+      // `...params` first, so `cacheControl` and `onCachedResponse` reach the
+      // request. Every shape above extends `RequestBaseParams`, so a caller
+      // may pass them, and `request` really reads `onCachedResponse` for its
+      // stale-while-revalidate path. Passing `config` alone advertised two
+      // options in the type and then dropped them both. The named fields
+      // below are written after, so they still win.
+      ...params,
+      config: params.config,
+      base: BASE,
+      url,
+      method,
+      metricsDetails: serviceContext,
+      body
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+}
+export {
+  ControlAnnotationsService
+};
+//# sourceMappingURL=control.annotations.service.js.map

package/dist/services/control/control.annotations.service.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/services/control/control.annotations.service.ts"],
+  "sourcesContent": ["/*\n * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH\n * under one or more contributor license agreements. Licensed under a commercial license.\n * You may not use this file except in compliance with the commercial license.\n */\n\nimport type {\n  AnnotationDto,\n  AnnotationEntityKind,\n  AnnotationKind,\n  AnnotationLookupDto,\n  AnnotationTagDto,\n  EntityAnnotationsDto,\n} from '@camunda/ccma-shared-types'\nimport type {\n  RequestBaseMethodType,\n  RequestBaseParams,\n  RequestBaseServiceContext,\n} from '../../types/general.types.js'\nimport { request } from '../../utils/api.js'\nimport { HttpError } from '../../utils/errors.js'\n\n/**\n * The annotation surface of control-backend: the notes and the tags that a\n * Camundi attaches to an entity of the fleet.\n *\n * One service for every kind of entity, and not one for each. The routes carry\n * the kind as a value, which is what lets one panel in control-frontend sit on\n * the cluster page, the organization page and every other entity page without\n * a call of its own.\n *\n * Every route answers 404 while the feature flag `control.annotations` is off\n * on the stage, and while the service reaches no stage at all.\n */\n\nconst BASE = { id: 'control' } as const\n\n/** What names the entity. Every write and the entity read carry it. */\nexport interface AnnotationTargetDto {\n  entityKind: AnnotationEntityKind\n  entityId: string\n  /**\n   * What the entity is called now. The backend stores it as a COPY, so a\n   * search result still reads after the entity is deleted. Send it when the\n   * caller knows the name.\n   */\n  entityLabel?: string\n}\n\nexport interface GetEntityAnnotationsRequest extends RequestBaseParams {\n  params: { entityKind: AnnotationEntityKind; entityId: string }\n}\n\nexport interface LookupAnnotationsRequest extends RequestBaseParams {\n  params: { entityKind: AnnotationEntityKind; entityIds: string[] }\n}\n\nexport interface AddAnnotationNoteRequest extends RequestBaseParams {\n  params: AnnotationTargetDto & { body: string }\n}\n\nexport interface EditAnnotationNoteRequest extends RequestBaseParams {\n  params: {\n    id: string\n    body: string\n    /**\n     * The `version` of the note that the caller read.\n     *\n     * The backend writes only while the row still carries it, and answers 409\n     * when it does not. Send what came with the note you are editing, never a\n     * number of your own: it is what stops a stale tab from replacing an edit\n     * that landed after it was opened.\n     */\n    version: number\n  }\n}\n\nexport interface AnnotationIdRequest extends RequestBaseParams {\n  params: { id: string }\n}\n\nexport interface AddAnnotationTagRequest extends RequestBaseParams {\n  params: AnnotationTargetDto & { tag: string }\n}\n\nexport interface ListAnnotationTagsRequest extends RequestBaseParams {\n  params?: { q?: string; limit?: number; offset?: number }\n}\n\nexport interface SearchAnnotationsRequest extends RequestBaseParams {\n  params?: {\n    kind?: AnnotationKind\n    entityKind?: AnnotationEntityKind\n    tag?: string\n    q?: string\n    limit?: number\n    offset?: number\n  }\n}\n\n/** One page of a read, and whether the table holds more of it. */\nexport interface AnnotationPageInfoDto {\n  limit: number\n  offset: number\n  /** True when the next page holds more. Never read the length instead. */\n  hasMore: boolean\n}\n\nexport interface AnnotationPageDto {\n  annotations: AnnotationDto[]\n  page: AnnotationPageInfoDto\n}\n\nexport interface AnnotationTagPageDto {\n  tags: AnnotationTagDto[]\n  page: AnnotationPageInfoDto\n}\n\nfunction contextFor(\n  name: string,\n  url: string,\n  normalizedUrl: string,\n  type: RequestBaseMethodType,\n  source: string,\n): RequestBaseServiceContext {\n  return {\n    method: {\n      name: `ControlAnnotationsService.${name}`,\n      url,\n      normalizedUrl,\n      type,\n    },\n    source,\n    target: { name: 'control', type: 'internal' },\n  }\n}\n\n/** Builds `?a=1&b=2` from the values that are set, and `''` from none. */\nfunction queryOf(params: Record<string, unknown> = {}): string {\n  const query = new URLSearchParams()\n  for (const [key, value] of Object.entries(params)) {\n    if (value !== undefined) {\n      query.set(key, String(value))\n    }\n  }\n  return query.size > 0 ? `?${query.toString()}` : ''\n}\n\nexport class ControlAnnotationsService {\n  /**\n   * Every live note and tag of one entity.\n   *\n   * An entity that carries nothing answers with two empty lists, and never\n   * 404. The call also answers for an entity that the fleet no longer holds,\n   * which is what keeps a link out of a search result working.\n   */\n  public static async forEntity(\n    params: GetEntityAnnotationsRequest,\n  ): Promise<EntityAnnotationsDto> {\n    const url = `api/annotations${queryOf(params.params)}`\n    return ControlAnnotationsService.send<EntityAnnotationsDto>(\n      params,\n      'forEntity',\n      url,\n      'api/annotations',\n      'get',\n    )\n  }\n\n  /**\n   * The tags, the note count and the newest note of many entities.\n   *\n   * A POST, because thousands of ids do not fit a request line. The answer\n   * holds only the entities that carry something.\n   */\n  public static async lookup(\n    params: LookupAnnotationsRequest,\n  ): Promise<AnnotationLookupDto> {\n    return ControlAnnotationsService.send<AnnotationLookupDto>(\n      params,\n      'lookup',\n      'api/annotations/lookup',\n      'api/annotations/lookup',\n      'post',\n      params.params,\n    )\n  }\n\n  /** Writes a note on an entity. Any signed-in Camundi can. */\n  public static async addNote(\n    params: AddAnnotationNoteRequest,\n  ): Promise<AnnotationDto> {\n    const { annotation } = await ControlAnnotationsService.send<{\n      annotation: AnnotationDto\n    }>(\n      params,\n      'addNote',\n      'api/annotations/notes',\n      'api/annotations/notes',\n      'post',\n      params.params,\n    )\n    return annotation\n  }\n\n  /** Changes the text of a note. Only the person who wrote it can. */\n  public static async editNote(\n    params: EditAnnotationNoteRequest,\n  ): Promise<AnnotationDto> {\n    const url = `api/annotations/notes/${params.params.id}`\n    const { annotation } = await ControlAnnotationsService.send<{\n      annotation: AnnotationDto\n    }>(params, 'editNote', url, 'api/annotations/notes/:id', 'patch', {\n      body: params.params.body,\n      version: params.params.version,\n    })\n    return annotation\n  }\n\n  /**\n   * Takes a note or a tag off an entity.\n   *\n   * The row stays: the removal is a soft delete, so who wrote it and who took\n   * it off both stay readable. A note can only be removed by its author; a tag\n   * can be removed by anybody.\n   */\n  public static async remove(params: AnnotationIdRequest): Promise<void> {\n    const url = `api/annotations/${params.params.id}`\n    await ControlAnnotationsService.send<undefined>(\n      params,\n      'remove',\n      url,\n      'api/annotations/:id',\n      'delete',\n    )\n  }\n\n  /**\n   * Attaches a tag to an entity, and adds it to the dictionary when it is new.\n   *\n   * The name is normalized by the backend, so `Partner` and `partner` reach\n   * one tag. A second attach of one tag on one entity answers 409.\n   */\n  public static async addTag(\n    params: AddAnnotationTagRequest,\n  ): Promise<AnnotationDto> {\n    const { annotation } = await ControlAnnotationsService.send<{\n      annotation: AnnotationDto\n    }>(\n      params,\n      'addTag',\n      'api/annotations/tags',\n      'api/annotations/tags',\n      'post',\n      params.params,\n    )\n    return annotation\n  }\n\n  /**\n   * The tag dictionary, with the live entities of each tag counted, most used\n   * first.\n   *\n   * The autocomplete of the tag field reads this. It is what stops one idea\n   * from becoming three spellings.\n   *\n   * It answers one PAGE, because the dictionary only grows. Read `page.hasMore`\n   * to learn whether another follows.\n   */\n  public static async listTags(\n    params: ListAnnotationTagsRequest,\n  ): Promise<AnnotationTagPageDto> {\n    const url = `api/annotations/tags${queryOf(params.params)}`\n    return ControlAnnotationsService.send<AnnotationTagPageDto>(\n      params,\n      'listTags',\n      url,\n      'api/annotations/tags',\n      'get',\n    )\n  }\n\n  /**\n   * One page of the annotations that match, newest first.\n   *\n   * The answer holds annotations of entities that no longer exist, which is\n   * the point: the note about a deleted cluster is often the only record of\n   * why it was there.\n   */\n  public static async search(\n    params: SearchAnnotationsRequest,\n  ): Promise<AnnotationPageDto> {\n    const url = `api/annotations/search${queryOf(params.params)}`\n    return ControlAnnotationsService.send<AnnotationPageDto>(\n      params,\n      'search',\n      url,\n      'api/annotations/search',\n      'get',\n    )\n  }\n\n  /**\n   * The shared half of every call above.\n   *\n   * Seven routes differ only in the verb, the path and the body. One private\n   * helper keeps the metrics context and the status check in one place.\n   */\n  private static async send<TResponse>(\n    params: RequestBaseParams,\n    name: string,\n    url: string,\n    normalizedUrl: string,\n    method: RequestBaseMethodType,\n    // `object` and not `Record<string, unknown>`: an interface has no index\n    // signature, so the request shapes above would not be assignable to one,\n    // and the alternative is `any`.\n    body?: object,\n  ): Promise<TResponse> {\n    const serviceContext = contextFor(\n      name,\n      url,\n      normalizedUrl,\n      method,\n      params.config.metrics?.source || 'unset',\n    )\n    const response = await request<TResponse>({\n      // `...params` first, so `cacheControl` and `onCachedResponse` reach the\n      // request. Every shape above extends `RequestBaseParams`, so a caller\n      // may pass them, and `request` really reads `onCachedResponse` for its\n      // stale-while-revalidate path. Passing `config` alone advertised two\n      // options in the type and then dropped them both. The named fields\n      // below are written after, so they still win.\n      ...params,\n      config: params.config,\n      base: BASE,\n      url,\n      method,\n      metricsDetails: serviceContext,\n      body,\n    })\n    if (!response.ok) {\n      throw new HttpError(\n        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,\n        response.status,\n        response.statusText,\n      )\n    }\n    // `remove` answers 204, which carries no body. Its caller declares\n    // `undefined` and reads nothing, so the assertion below is safe for it\n    // too: every other route here answers a body.\n    return response.body as TResponse\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/services/control/control.approvals.service.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalJobDto, ApprovalJobStatus, ApprovalUseCaseDto } from '@camunda/ccma-shared-types';
+import type { ApprovalEntityType, ApprovalJobDto, ApprovalJobStatus, ApprovalSortField, ApprovalSortOrder, ApprovalStatusCountsDto, ApprovalUseCaseDto, ClusterBulkOperationPayloadDto, ClusterBulkOperationType, FeatureFlagOverridePayloadDto } from '@camunda/ccma-shared-types';
 import type { RequestBaseParams } from '../../types/general.types.js';
 export interface ApprovalPageDto {
     approvals: ApprovalJobDto[];
@@ -9,14 +9,66 @@ export interface ApprovalPageDto {
         hasMore: boolean;
     };
 }
+/**
+ * What narrows the queue. The list and the counts read the same fields.
+ *
+ * `entityType` and `entityId` are ONE filter, not two. control-backend answers
+ * 400 for one without the other, so the type carries both or neither.
+ */
+export type ApprovalFacetParams = {
+    type?: string;
+    /**
+     * One organization, matched whole against `orgId` of the payload.
+     *
+     * It reads only the payload, so `entityType`/`entityId` is wider. That filter
+     * reads the entity link, so it finds a request that touches the organization
+     * through another field. The organization page of control-frontend asks the
+     * entity-link filter, not this one. `orgId` is also not `q`: the free text
+     * reads the whole payload as text.
+     */
+    orgId?: string;
+    /**
+     * Free text. control-backend matches it in the reason, the person who
+     * opened the request, the action and its label, and the payload that the
+     * summary shows.
+     */
+    q?: string;
+    /**
+     * The queue of one person: what they opened, or what waits for them.
+     *
+     * `actionable` is the rule of the Approve button asked in SQL — pending,
+     * opened by somebody else, not approved by this person yet, and guarded by
+     * permissions that they hold.
+     */
+    mine?: 'created' | 'actionable';
+} & ({
+    /**
+     * The kind of entity a request must touch. Read with `entityId`.
+     *
+     * It reads the entity link of control-backend, so it is wider and truer
+     * than `orgId`: a cluster-move request answers for its source
+     * organization, its target organization AND the cluster. The organization
+     * and cluster detail pages of control-frontend ask this.
+     */
+    entityType: ApprovalEntityType;
+    /** The id of the entity a request must touch. Read with `entityType`. */
+    entityId: string;
+} | {
+    entityType?: never;
+    entityId?: never;
+});
 export interface ListApprovalsRequest extends RequestBaseParams {
-    params?: {
-        type?: string;
+    params?: ApprovalFacetParams & {
         status?: ApprovalJobStatus;
+        sort?: ApprovalSortField;
+        order?: ApprovalSortOrder;
         limit?: number;
         offset?: number;
     };
 }
+export interface CountApprovalsRequest extends RequestBaseParams {
+    params?: ApprovalFacetParams;
+}
 export interface ApprovalIdRequest extends RequestBaseParams {
     params: {
         id: string;
@@ -28,6 +80,13 @@ export interface RejectApprovalRequest extends RequestBaseParams {
         reason: string;
     };
 }
+/** A withdrawal says why, or says nothing. The reason is not demanded. */
+export interface WithdrawApprovalRequest extends RequestBaseParams {
+    params: {
+        id: string;
+        reason?: string;
+    };
+}
 /** The envelope that every create route of every use case shares. */
 export interface CreateApprovalRequest<TPayload> extends RequestBaseParams {
     params: {
@@ -54,6 +113,14 @@ export interface ExtendTrialPayloadDto {
      */
     days: number;
 }
+export interface MoveClusterOrgPayloadDto {
+    clusterId: string;
+    /** A copy, so a list shows a name that a person knows. Nothing reads it. */
+    clusterName?: string;
+    targetOrgId: string;
+    /** A copy, for the same reason as `clusterName`. */
+    targetOrgName?: string;
+}
 export declare class ControlApprovalsService {
     /**
      * The registered privileged actions, with the rules that guard each one.
@@ -70,13 +137,51 @@ export declare class ControlApprovalsService {
      * the caller cannot act on, unless the caller opened it.
      */
     static list(params: ListApprovalsRequest): Promise<ApprovalPageDto>;
+    /**
+     * How many requests each status holds, for the status filters of a queue.
+     *
+     * It is the same question as `list` without the status, so a filter that
+     * shows a number never opens an empty page.
+     */
+    static counts(params: CountApprovalsRequest): Promise<ApprovalStatusCountsDto>;
     static get(params: ApprovalIdRequest): Promise<ApprovalJobDto>;
+    /**
+     * What a create route answers, plus whether it opened a NEW request.
+     *
+     * The route answers 201 for a fresh request and 200 for the one already
+     * open for the same target — `create` deduplicates. A caller that must
+     * tell the two apart (a floor-of-one use case, where 200 is the ordinary
+     * path and not a failure) reads `created`.
+     */
+    static createMoveClusterOrg(params: CreateApprovalRequest<MoveClusterOrgPayloadDto>): Promise<{
+        approval: ApprovalJobDto;
+        created: boolean;
+    }>;
+    /**
+     * Opens a cluster bulk operation of one type.
+     *
+     * Each type is its own use case with its own route, because each one has
+     * its own permission. The floor of approvals is the same for every type,
+     * and it depends on the stage: 2 on prod, 1 on dev, int and local. The
+     * route is `api/approvals/<use case>`, as for every other use case. A 200
+     * means that the same operation over the same clusters is already open.
+     */
+    static createClusterBulkOperation<T extends ClusterBulkOperationType>(type: T, params: CreateApprovalRequest<ClusterBulkOperationPayloadDto<T>>): Promise<{
+        approval: ApprovalJobDto;
+        created: boolean;
+    }>;
     /** Adds the approval of the caller. The last one can run the action. */
     static acknowledge(params: ApprovalIdRequest): Promise<ApprovalJobDto>;
     /** Closes a request without running the action. The reason is necessary. */
     static reject(params: RejectApprovalRequest): Promise<ApprovalJobDto>;
-    /** Takes back a request. Only the person who opened it can. */
-    static withdraw(params: ApprovalIdRequest): Promise<ApprovalJobDto>;
+    /**
+     * Takes back a request. Only the person who opened it can.
+     *
+     * The reason is optional, and it lands in the same field that a rejection
+     * writes. The creator cannot reject their own request, so this is where they
+     * say why they closed it.
+     */
+    static withdraw(params: WithdrawApprovalRequest): Promise<ApprovalJobDto>;
     /**
      * Runs a request that holds its approvals.
      *
@@ -94,6 +199,18 @@ export declare class ControlApprovalsService {
      * approving needs, and the reason is necessary.
      */
     static createExtendTrial(params: CreateApprovalRequest<ExtendTrialPayloadDto>): Promise<ApprovalJobDto>;
+    /**
+     * Opens a feature-flag-override request.
+     *
+     * Opening one needs the feature flag permission, the same one that
+     * approving needs, and the reason is necessary. A stage override that names
+     * `prod` needs the prod permission on top, to ask AND to approve.
+     *
+     * The payload holds a number of DAYS and not a date. Every override ends:
+     * without a deadline the store becomes a second, invisible layer of
+     * configuration.
+     */
+    static createFeatureFlagOverride(params: CreateApprovalRequest<FeatureFlagOverridePayloadDto>): Promise<ApprovalJobDto>;
     /**
      * The shared half of every call that answers one request.
      *
@@ -102,6 +219,13 @@ export declare class ControlApprovalsService {
      * unwrapping in one place.
      */
     private static readOne;
-    /** The shared half of every create route. See `approvalRequestBody`. */
+    /**
+     * The shared half of every create route. See `approvalRequestBody`.
+     *
+     * The route answers 201 for a fresh request and 200 for the one already
+     * open for the same target (`create` deduplicates). `created` carries that
+     * difference. `createSendToExpiredTrial` and `createExtendTrial` do not
+     * need it, so they read `approval` alone off this result.
+     */
     private static create;
 }

package/dist/services/control/control.approvals.service.js

@@ -1,6 +1,16 @@
+import { CLUSTER_BULK_OPERATION_RULES } from "@camunda/ccma-shared-types";
 import { request } from "../../utils/api.js";
 import { HttpError } from "../../utils/errors.js";
 const BASE = { id: "control" };
+function querySuffix(params = {}) {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== "") {
+      query.set(key, String(value));
+    }
+  }
+  return query.size > 0 ? `?${query.toString()}` : "";
+}
 function contextFor(name, url, normalizedUrl, type, source) {
   return {
     method: {
@@ -52,13 +62,7 @@ class ControlApprovalsService {
    * the caller cannot act on, unless the caller opened it.
    */
   static async list(params) {
-    const query = new URLSearchParams();
-    for (const [key, value] of Object.entries(params.params ?? {})) {
-      if (value !== void 0) {
-        query.set(key, String(value));
-      }
-    }
-    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    const suffix = querySuffix(params.params);
     const serviceContext = contextFor(
       "list",
       `api/approvals${suffix}`,
@@ -82,6 +86,37 @@ class ControlApprovalsService {
     }
     return response.body;
   }
+  /**
+   * How many requests each status holds, for the status filters of a queue.
+   *
+   * It is the same question as `list` without the status, so a filter that
+   * shows a number never opens an empty page.
+   */
+  static async counts(params) {
+    const suffix = querySuffix(params.params);
+    const serviceContext = contextFor(
+      "counts",
+      `api/approvals/counts${suffix}`,
+      "api/approvals/counts",
+      "get",
+      params.config.metrics?.source || "unset"
+    );
+    const response = await request({
+      config: params.config,
+      base: BASE,
+      url: serviceContext.method.url,
+      method: "get",
+      metricsDetails: serviceContext
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body.counts;
+  }
   static async get(params) {
     return ControlApprovalsService.readOne(
       params,
@@ -91,6 +126,38 @@ class ControlApprovalsService {
       "get"
     );
   }
+  /**
+   * What a create route answers, plus whether it opened a NEW request.
+   *
+   * The route answers 201 for a fresh request and 200 for the one already
+   * open for the same target — `create` deduplicates. A caller that must
+   * tell the two apart (a floor-of-one use case, where 200 is the ordinary
+   * path and not a failure) reads `created`.
+   */
+  static async createMoveClusterOrg(params) {
+    return ControlApprovalsService.create(
+      params,
+      "createMoveClusterOrg",
+      "api/approvals/move-cluster-org"
+    );
+  }
+  /**
+   * Opens a cluster bulk operation of one type.
+   *
+   * Each type is its own use case with its own route, because each one has
+   * its own permission. The floor of approvals is the same for every type,
+   * and it depends on the stage: 2 on prod, 1 on dev, int and local. The
+   * route is `api/approvals/<use case>`, as for every other use case. A 200
+   * means that the same operation over the same clusters is already open.
+   */
+  static async createClusterBulkOperation(type, params) {
+    const useCase = CLUSTER_BULK_OPERATION_RULES[type].useCase;
+    return ControlApprovalsService.create(
+      params,
+      "createClusterBulkOperation",
+      `api/approvals/${useCase}`
+    );
+  }
   /** Adds the approval of the caller. The last one can run the action. */
   static async acknowledge(params) {
     return ControlApprovalsService.readOne(
@@ -112,14 +179,21 @@ class ControlApprovalsService {
       { reason: params.params.reason }
     );
   }
-  /** Takes back a request. Only the person who opened it can. */
+  /**
+   * Takes back a request. Only the person who opened it can.
+   *
+   * The reason is optional, and it lands in the same field that a rejection
+   * writes. The creator cannot reject their own request, so this is where they
+   * say why they closed it.
+   */
   static async withdraw(params) {
     return ControlApprovalsService.readOne(
       params,
       "withdraw",
       `api/approvals/${params.params.id}/withdraw`,
       "api/approvals/:id/withdraw",
-      "post"
+      "post",
+      params.params.reason ? { reason: params.params.reason } : void 0
     );
   }
   /**
@@ -140,11 +214,12 @@ class ControlApprovalsService {
   }
   /** Opens a send-to-expired-trial request. Any signed-in Camundi can. */
   static async createSendToExpiredTrial(params) {
-    return ControlApprovalsService.create(
+    const { approval } = await ControlApprovalsService.create(
       params,
       "createSendToExpiredTrial",
       "api/approvals/send-to-expired-trial"
     );
+    return approval;
   }
   /**
    * Opens an extend-trial request.
@@ -153,11 +228,31 @@ class ControlApprovalsService {
    * approving needs, and the reason is necessary.
    */
   static async createExtendTrial(params) {
-    return ControlApprovalsService.create(
+    const { approval } = await ControlApprovalsService.create(
       params,
       "createExtendTrial",
       "api/approvals/extend-trial"
     );
+    return approval;
+  }
+  /**
+   * Opens a feature-flag-override request.
+   *
+   * Opening one needs the feature flag permission, the same one that
+   * approving needs, and the reason is necessary. A stage override that names
+   * `prod` needs the prod permission on top, to ask AND to approve.
+   *
+   * The payload holds a number of DAYS and not a date. Every override ends:
+   * without a deadline the store becomes a second, invisible layer of
+   * configuration.
+   */
+  static async createFeatureFlagOverride(params) {
+    const { approval } = await ControlApprovalsService.create(
+      params,
+      "createFeatureFlagOverride",
+      "api/approvals/feature-flag-override"
+    );
+    return approval;
   }
   /**
    * The shared half of every call that answers one request.
@@ -191,7 +286,14 @@ class ControlApprovalsService {
     }
     return response.body.approval;
   }
-  /** The shared half of every create route. See `approvalRequestBody`. */
+  /**
+   * The shared half of every create route. See `approvalRequestBody`.
+   *
+   * The route answers 201 for a fresh request and 200 for the one already
+   * open for the same target (`create` deduplicates). `created` carries that
+   * difference. `createSendToExpiredTrial` and `createExtendTrial` do not
+   * need it, so they read `approval` alone off this result.
+   */
   static async create(params, name, url) {
     const serviceContext = contextFor(
       name,
@@ -219,7 +321,10 @@ class ControlApprovalsService {
         response.statusText
       );
     }
-    return response.body.approval;
+    return {
+      approval: response.body.approval,
+      created: response.status === 201
+    };
   }
 }
 export {