@camunda/ccma-api 2.0.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

@@ -0,0 +1,231 @@
+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[];
+    page: {
+        limit: number;
+        offset: number;
+        /** True when the next page holds more. Never read the length instead. */
+        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?: 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;
+    };
+}
+export interface RejectApprovalRequest extends RequestBaseParams {
+    params: {
+        id: string;
+        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: {
+        payload: TPayload;
+        reason?: string;
+        /** More approvals than the floor of the use case. Never fewer. */
+        requiredAcks?: number;
+    };
+}
+export interface SendToExpiredTrialPayloadDto {
+    orgId: string;
+    orgName?: string;
+}
+export interface ExtendTrialPayloadDto {
+    orgId: string;
+    orgName?: string;
+    /**
+     * Days of trial counted from the moment the action RUNS.
+     *
+     * Never a date. Accounts holds the new expiry inside a window that it
+     * measures when the call arrives, and under approvals that is days after the
+     * person chose the value. See `use-cases/extend-trial.ts` in
+     * control-backend.
+     */
+    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.
+     *
+     * A frontend reads this to run the same policy as the service, so it never
+     * holds a copy of the registry. A new use case then needs no frontend
+     * deploy.
+     */
+    static listUseCases(params: RequestBaseParams): Promise<ApprovalUseCaseDto[]>;
+    /**
+     * One page of the requests that the caller can read.
+     *
+     * It is not the whole table: control-backend hides a request whose use case
+     * 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.
+     *
+     * 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.
+     *
+     * Only a use case in the explicit mode needs this. An action that throws
+     * leaves the request `failed`, and this call still answers 200 with it, so
+     * read `status` and `executionError` of the answer.
+     */
+    static execute(params: ApprovalIdRequest): Promise<ApprovalJobDto>;
+    /** Opens a send-to-expired-trial request. Any signed-in Camundi can. */
+    static createSendToExpiredTrial(params: CreateApprovalRequest<SendToExpiredTrialPayloadDto>): Promise<ApprovalJobDto>;
+    /**
+     * Opens an extend-trial request.
+     *
+     * Opening one needs `accounts:admin:extendTrial`, the same permission that
+     * 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.
+     *
+     * Six routes answer `{ approval }` and differ only in the verb and the path.
+     * One private helper keeps the metrics context, the status check and the
+     * unwrapping in one place.
+     */
+    private static readOne;
+    /**
+     * 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;
+}