@ghx-dev/core 0.1.2 → 0.2.0

package/dist/issue-mutations-FJNZW7L5.js

@@ -0,0 +1,668 @@
+import {
+  getSdk,
+  getSdk10,
+  getSdk11,
+  getSdk12,
+  getSdk13,
+  getSdk14,
+  getSdk15,
+  getSdk16,
+  getSdk17,
+  getSdk18,
+  getSdk19,
+  getSdk2,
+  getSdk20,
+  getSdk21,
+  getSdk22,
+  getSdk3,
+  getSdk4,
+  getSdk5,
+  getSdk6,
+  getSdk7,
+  getSdk8,
+  getSdk9
+} from "./chunk-Q7RCIK2C.js";
+import "./chunk-3DU2WHXF.js";
+import {
+  PrCoreFieldsFragmentDoc
+} from "./chunk-TPQYVCAS.js";
+import {
+  asRecord,
+  assertIssueAssigneesAddInput,
+  assertIssueAssigneesRemoveInput,
+  assertIssueAssigneesUpdateInput,
+  assertIssueBlockedByInput,
+  assertIssueCommentCreateInput,
+  assertIssueCreateInput,
+  assertIssueLabelsAddInput,
+  assertIssueLabelsUpdateInput,
+  assertIssueLinkedPrsListInput,
+  assertIssueMilestoneSetInput,
+  assertIssueMutationInput,
+  assertIssueParentRemoveInput,
+  assertIssueParentSetInput,
+  assertIssueRelationsGetInput,
+  assertIssueUpdateInput,
+  assertNonEmptyString
+} from "./chunk-BIWBJA2F.js";
+import {
+  createGraphqlRequestClient
+} from "./chunk-HEHONZTO.js";
+
+// src/gql/operations/issue-linked-prs-list.generated.ts
+var IssueLinkedPrsListDocument = `
+    query IssueLinkedPrsList($owner: String!, $name: String!, $issueNumber: Int!) {
+  repository(owner: $owner, name: $name) {
+    issue(number: $issueNumber) {
+      timelineItems(first: 50, itemTypes: [CONNECTED_EVENT]) {
+        nodes {
+          __typename
+          ... on ConnectedEvent {
+            subject {
+              __typename
+              ... on PullRequest {
+                ...PrCoreFields
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+    ${PrCoreFieldsFragmentDoc}`;
+var defaultWrapper = (action, _operationName, _operationType, _variables) => action();
+function getSdk23(client, withWrapper = defaultWrapper) {
+  return {
+    IssueLinkedPrsList(variables, requestHeaders, signal) {
+      return withWrapper(
+        (wrappedRequestHeaders) => client.request({
+          document: IssueLinkedPrsListDocument,
+          variables,
+          requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+          signal
+        }),
+        "IssueLinkedPrsList",
+        "query",
+        variables
+      );
+    }
+  };
+}
+
+// src/gql/operations/issue-relations-get.generated.ts
+var IssueRelationsGetDocument = `
+    query IssueRelationsGet($owner: String!, $name: String!, $issueNumber: Int!) {
+  repository(owner: $owner, name: $name) {
+    issue(number: $issueNumber) {
+      id
+      number
+      parent {
+        id
+        number
+      }
+      subIssues(first: 50) {
+        nodes {
+          id
+          number
+        }
+      }
+      blockedBy(first: 50) {
+        nodes {
+          id
+          number
+        }
+      }
+    }
+  }
+}
+    `;
+var defaultWrapper2 = (action, _operationName, _operationType, _variables) => action();
+function getSdk24(client, withWrapper = defaultWrapper2) {
+  return {
+    IssueRelationsGet(variables, requestHeaders, signal) {
+      return withWrapper(
+        (wrappedRequestHeaders) => client.request({
+          document: IssueRelationsGetDocument,
+          variables,
+          requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders },
+          signal
+        }),
+        "IssueRelationsGet",
+        "query",
+        variables
+      );
+    }
+  };
+}
+
+// src/gql/domains/issue-mutations.ts
+function parseIssueNode(issue) {
+  const issueRecord = asRecord(issue);
+  if (!issueRecord || typeof issueRecord.id !== "string" || typeof issueRecord.number !== "number") {
+    throw new Error("Issue mutation failed");
+  }
+  const result = {
+    id: issueRecord.id,
+    number: issueRecord.number
+  };
+  if (typeof issueRecord.title === "string") {
+    result.title = issueRecord.title;
+  }
+  if (typeof issueRecord.state === "string") {
+    result.state = issueRecord.state;
+  }
+  if (typeof issueRecord.url === "string") {
+    result.url = issueRecord.url;
+  }
+  return result;
+}
+async function runIssueCreate(transport, input) {
+  assertIssueCreateInput(input);
+  const client = createGraphqlRequestClient(transport);
+  const repositoryLookupResult = await getSdk10(
+    client
+  ).IssueCreateRepositoryId({
+    owner: input.owner,
+    name: input.name
+  });
+  const repositoryId = asRecord(repositoryLookupResult.repository)?.id;
+  if (typeof repositoryId !== "string" || repositoryId.length === 0) {
+    throw new Error("Repository not found");
+  }
+  const result = await getSdk9(client).IssueCreate({
+    repositoryId,
+    title: input.title,
+    ...input.body === void 0 ? {} : { body: input.body }
+  });
+  const issue = asRecord(asRecord(result)?.createIssue)?.issue;
+  return parseIssueNode(issue);
+}
+async function runIssueUpdate(transport, input) {
+  assertIssueUpdateInput(input);
+  const client = createGraphqlRequestClient(transport);
+  const lookupResult = await getSdk17(client).IssueNodeIdLookup({
+    owner: input.owner,
+    name: input.name,
+    issueNumber: input.issueNumber
+  });
+  const issueId = asRecord(asRecord(asRecord(lookupResult)?.repository)?.issue)?.id;
+  if (typeof issueId !== "string" || issueId.length === 0) {
+    throw new Error("Issue not found");
+  }
+  const result = await getSdk22(client).IssueUpdate({
+    issueId,
+    ...input.title === void 0 ? {} : { title: input.title },
+    ...input.body === void 0 ? {} : { body: input.body }
+  });
+  const issue = asRecord(asRecord(result)?.updateIssue)?.issue;
+  return parseIssueNode(issue);
+}
+async function runIssueClose(transport, input) {
+  assertIssueMutationInput(input);
+  const client = createGraphqlRequestClient(transport);
+  const lookupResult = await getSdk17(client).IssueNodeIdLookup({
+    owner: input.owner,
+    name: input.name,
+    issueNumber: input.issueNumber
+  });
+  const issueId = asRecord(asRecord(asRecord(lookupResult)?.repository)?.issue)?.id;
+  if (typeof issueId !== "string" || issueId.length === 0) {
+    throw new Error("Issue not found");
+  }
+  const result = await getSdk7(client).IssueClose({ issueId });
+  const issueData = parseIssueNode(asRecord(asRecord(result)?.closeIssue)?.issue);
+  return {
+    ...issueData,
+    closed: issueData.state === "CLOSED"
+  };
+}
+async function runIssueReopen(transport, input) {
+  assertIssueMutationInput(input);
+  const client = createGraphqlRequestClient(transport);
+  const lookupResult = await getSdk17(client).IssueNodeIdLookup({
+    owner: input.owner,
+    name: input.name,
+    issueNumber: input.issueNumber
+  });
+  const issueId = asRecord(asRecord(asRecord(lookupResult)?.repository)?.issue)?.id;
+  if (typeof issueId !== "string" || issueId.length === 0) {
+    throw new Error("Issue not found");
+  }
+  const result = await getSdk21(client).IssueReopen({ issueId });
+  const issueData = parseIssueNode(asRecord(asRecord(result)?.reopenIssue)?.issue);
+  return {
+    ...issueData,
+    reopened: issueData.state === "OPEN"
+  };
+}
+async function runIssueDelete(transport, input) {
+  assertIssueMutationInput(input);
+  const client = createGraphqlRequestClient(transport);
+  const lookupResult = await getSdk17(client).IssueNodeIdLookup({
+    owner: input.owner,
+    name: input.name,
+    issueNumber: input.issueNumber
+  });
+  const issueId = asRecord(asRecord(asRecord(lookupResult)?.repository)?.issue)?.id;
+  if (typeof issueId !== "string" || issueId.length === 0) {
+    throw new Error("Issue not found");
+  }
+  const result = await getSdk11(client).IssueDelete({ issueId });
+  const mutation = asRecord(asRecord(result)?.deleteIssue);
+  if (!mutation) {
+    throw new Error("Issue deletion failed");
+  }
+  return {
+    id: issueId,
+    number: 0,
+    deleted: true
+  };
+}
+async function runIssueLabelsUpdate(transport, input) {
+  assertIssueLabelsUpdateInput(input);
+  const client = createGraphqlRequestClient(transport);
+  const lookupResult = await getSdk13(client).IssueLabelsLookupByNumber({
+    owner: input.owner,
+    name: input.name,
+    issueNumber: input.issueNumber
+  });
+  const repo = asRecord(asRecord(lookupResult)?.repository);
+  const issueId = asRecord(repo?.issue)?.id;
+  if (typeof issueId !== "string" || issueId.length === 0) {
+    throw new Error("Issue not found");
+  }
+  const availableLabels = Array.isArray(asRecord(repo?.labels)?.nodes) ? asRecord(repo?.labels)?.nodes : [];
+  const labelIdsByName = /* @__PURE__ */ new Map();
+  for (const label of availableLabels) {
+    const labelRecord = asRecord(label);
+    if (typeof labelRecord?.name === "string" && typeof labelRecord?.id === "string") {
+      labelIdsByName.set(labelRecord.name.toLowerCase(), labelRecord.id);
+    }
+  }
+  const labelIds = input.labels.map((labelName) => {
+    const id = labelIdsByName.get(labelName.toLowerCase());
+    if (!id) {
+      throw new Error(`Label not found: ${labelName}`);
+    }
+    return id;
+  });
+  const result = await getSdk14(client).IssueLabelsUpdate({
+    issueId,
+    labelIds
+  });
+  const mutation = asRecord(asRecord(result)?.["updateIssue"]);
+  const issue = asRecord(mutation?.["issue"]);
+  const labels = asRecord(issue?.["labels"]);
+  const labelNodes = Array.isArray(labels?.["nodes"]) ? labels["nodes"] : [];
+  return {
+    id: assertNonEmptyString(issue?.["id"], "Issue id"),
+    labels: labelNodes.map((label) => asRecord(label)?.["name"]).filter((name) => typeof name === "string")
+  };
+}
+async function runIssueLabelsAdd(transport, input) {
+  assertIssueLabelsAddInput(input);
+  const client = createGraphqlRequestClient(transport);
+  const lookupResult = await getSdk13(client).IssueLabelsLookupByNumber({
+    owner: input.owner,
+    name: input.name,
+    issueNumber: input.issueNumber
+  });
+  const repo = asRecord(asRecord(lookupResult)?.repository);
+  const labelableId = asRecord(repo?.issue)?.id;
+  if (typeof labelableId !== "string" || labelableId.length === 0) {
+    throw new Error("Issue not found");
+  }
+  const availableLabels = Array.isArray(asRecord(repo?.labels)?.nodes) ? asRecord(repo?.labels)?.nodes : [];
+  const labelIdsByName = /* @__PURE__ */ new Map();
+  for (const label of availableLabels) {
+    const labelRecord = asRecord(label);
+    if (typeof labelRecord?.name === "string" && typeof labelRecord?.id === "string") {
+      labelIdsByName.set(labelRecord.name.toLowerCase(), labelRecord.id);
+    }
+  }
+  const labelIds = input.labels.map((labelName) => {
+    const id = labelIdsByName.get(labelName.toLowerCase());
+    if (!id) {
+      throw new Error(`Label not found: ${labelName}`);
+    }
+    return id;
+  });
+  const result = await getSdk12(client).IssueLabelsAdd({
+    labelableId,
+    labelIds
+  });
+  const mutation = asRecord(asRecord(result)?.["addLabelsToLabelable"]);
+  const labelable = asRecord(mutation?.["labelable"]);
+  const labels = asRecord(labelable?.["labels"]);
+  const labelNodes = Array.isArray(labels?.["nodes"]) ? labels["nodes"] : [];
+  return {
+    id: assertNonEmptyString(labelable?.["id"], "Issue id"),
+    labels: labelNodes.map((label) => asRecord(label)?.["name"]).filter((name) => typeof name === "string")
+  };
+}
+async function runIssueAssigneesUpdate(transport, input) {
+  assertIssueAssigneesUpdateInput(input);
+  const client = createGraphqlRequestClient(transport);
+  const lookupResult = await getSdk2(
+    client
+  ).IssueAssigneesLookupByNumber({
+    owner: input.owner,
+    name: input.name,
+    issueNumber: input.issueNumber
+  });
+  const { assignableId, assigneeIds } = resolveAssigneeIds(lookupResult, input.assignees);
+  const result = await getSdk4(client).IssueAssigneesUpdate({
+    issueId: assignableId,
+    assigneeIds
+  });
+  const mutation = asRecord(asRecord(result)?.["updateIssue"]);
+  const issue = asRecord(mutation?.["issue"]);
+  const assignees = asRecord(issue?.["assignees"]);
+  const assigneeNodes = Array.isArray(assignees?.["nodes"]) ? assignees["nodes"] : [];
+  return {
+    id: assertNonEmptyString(issue?.["id"], "Issue id"),
+    assignees: assigneeNodes.map((assignee) => asRecord(assignee)?.["login"]).filter((login) => typeof login === "string")
+  };
+}
+function resolveAssigneeIds(lookupResult, assigneeLogins) {
+  const repo = asRecord(asRecord(lookupResult)?.repository);
+  const issueId = asRecord(repo?.issue)?.id;
+  if (typeof issueId !== "string" || issueId.length === 0) {
+    throw new Error("Issue not found");
+  }
+  const assignableNodes = Array.isArray(asRecord(repo?.assignableUsers)?.nodes) ? asRecord(repo?.assignableUsers)?.nodes : [];
+  const idsByLogin = /* @__PURE__ */ new Map();
+  for (const node of assignableNodes) {
+    const rec = asRecord(node);
+    if (typeof rec?.login === "string" && typeof rec?.id === "string") {
+      idsByLogin.set(rec.login.toLowerCase(), rec.id);
+    }
+  }
+  const assigneeIds = assigneeLogins.map((login) => {
+    const id = idsByLogin.get(login.toLowerCase());
+    if (!id) {
+      throw new Error(`Assignee not found: ${login}`);
+    }
+    return id;
+  });
+  return { assignableId: issueId, assigneeIds };
+}
+function parseAssignableResult(result, mutationKey) {
+  const mutation = asRecord(asRecord(result)?.[mutationKey]);
+  const assignable = asRecord(mutation?.assignable);
+  const assignees = asRecord(assignable?.assignees);
+  const nodes = Array.isArray(assignees?.nodes) ? assignees.nodes : [];
+  return {
+    id: assertNonEmptyString(assignable?.id, "Issue id"),
+    assignees: nodes.map((n) => asRecord(n)?.login).filter((login) => typeof login === "string")
+  };
+}
+async function runIssueAssigneesAdd(transport, input) {
+  assertIssueAssigneesAddInput(input);
+  const client = createGraphqlRequestClient(transport);
+  const lookupResult = await getSdk2(
+    client
+  ).IssueAssigneesLookupByNumber({
+    owner: input.owner,
+    name: input.name,
+    issueNumber: input.issueNumber
+  });
+  const { assignableId, assigneeIds } = resolveAssigneeIds(lookupResult, input.assignees);
+  const result = await getSdk(client).IssueAssigneesAdd({
+    assignableId,
+    assigneeIds
+  });
+  return parseAssignableResult(result, "addAssigneesToAssignable");
+}
+async function runIssueAssigneesRemove(transport, input) {
+  assertIssueAssigneesRemoveInput(input);
+  const client = createGraphqlRequestClient(transport);
+  const lookupResult = await getSdk2(
+    client
+  ).IssueAssigneesLookupByNumber({
+    owner: input.owner,
+    name: input.name,
+    issueNumber: input.issueNumber
+  });
+  const { assignableId, assigneeIds } = resolveAssigneeIds(lookupResult, input.assignees);
+  const result = await getSdk3(client).IssueAssigneesRemove({
+    assignableId,
+    assigneeIds
+  });
+  return parseAssignableResult(result, "removeAssigneesFromAssignable");
+}
+async function runIssueMilestoneSet(transport, input) {
+  assertIssueMilestoneSetInput(input);
+  const client = createGraphqlRequestClient(transport);
+  const lookupResult = await getSdk15(
+    client
+  ).IssueMilestoneLookupByNumber({
+    owner: input.owner,
+    name: input.name,
+    issueNumber: input.issueNumber,
+    milestoneNumber: input.milestoneNumber
+  });
+  const repo = asRecord(asRecord(lookupResult)?.repository);
+  const issueId = asRecord(repo?.issue)?.id;
+  const milestoneId = asRecord(repo?.milestone)?.id;
+  if (typeof issueId !== "string" || issueId.length === 0) {
+    throw new Error("Issue not found");
+  }
+  if (typeof milestoneId !== "string" || milestoneId.length === 0) {
+    throw new Error(`Milestone not found: ${input.milestoneNumber}`);
+  }
+  const result = await getSdk16(client).IssueMilestoneSet({
+    issueId,
+    milestoneId
+  });
+  const mutation = asRecord(asRecord(result)?.["updateIssue"]);
+  const issue = asRecord(mutation?.["issue"]);
+  const milestone = asRecord(issue?.["milestone"]);
+  return {
+    id: assertNonEmptyString(issue?.["id"], "Issue id"),
+    milestoneNumber: typeof milestone?.["number"] === "number" ? milestone["number"] : null
+  };
+}
+async function runIssueCommentCreate(transport, input) {
+  assertIssueCommentCreateInput(input);
+  const client = createGraphqlRequestClient(transport);
+  const lookupResult = await getSdk17(client).IssueNodeIdLookup({
+    owner: input.owner,
+    name: input.name,
+    issueNumber: input.issueNumber
+  });
+  const issueId = asRecord(asRecord(asRecord(lookupResult)?.repository)?.issue)?.id;
+  if (typeof issueId !== "string" || issueId.length === 0) {
+    throw new Error("Issue not found");
+  }
+  const result = await getSdk8(client).IssueCommentCreate({
+    issueId,
+    body: input.body
+  });
+  const mutation = asRecord(asRecord(result)?.["addComment"]);
+  const commentEdge = asRecord(mutation?.["commentEdge"]);
+  const node = asRecord(commentEdge?.["node"]);
+  if (!node || typeof node["id"] !== "string" || typeof node["body"] !== "string") {
+    throw new Error("Issue comment creation failed");
+  }
+  return {
+    id: node["id"],
+    body: node["body"],
+    url: typeof node["url"] === "string" ? node["url"] : ""
+  };
+}
+async function runIssueLinkedPrsList(transport, input) {
+  assertIssueLinkedPrsListInput(input);
+  const result = await getSdk23(
+    createGraphqlRequestClient(transport)
+  ).IssueLinkedPrsList({
+    owner: input.owner,
+    name: input.name,
+    issueNumber: input.issueNumber
+  });
+  const issue = asRecord(asRecord(asRecord(result)?.repository)?.issue);
+  const timelineItems = asRecord(issue?.timelineItems);
+  const nodes = Array.isArray(timelineItems?.nodes) ? timelineItems.nodes : [];
+  return {
+    items: nodes.map((node) => asRecord(asRecord(node)?.["subject"])).filter(
+      (subject) => Boolean(subject) && subject?.["__typename"] === "PullRequest"
+    ).flatMap((subject) => {
+      if (!subject) {
+        return [];
+      }
+      if (typeof subject["id"] !== "string" || typeof subject["number"] !== "number" || typeof subject["title"] !== "string" || typeof subject["state"] !== "string" || typeof subject["url"] !== "string") {
+        return [];
+      }
+      return [
+        {
+          id: subject["id"],
+          number: subject["number"],
+          title: subject["title"],
+          state: subject["state"],
+          url: subject["url"]
+        }
+      ];
+    })
+  };
+}
+function parseIssueRelationNode(node) {
+  const record = asRecord(node);
+  if (!record || typeof record.id !== "string" || typeof record.number !== "number") {
+    return null;
+  }
+  return {
+    id: record.id,
+    number: record.number
+  };
+}
+async function runIssueRelationsGet(transport, input) {
+  assertIssueRelationsGetInput(input);
+  const result = await getSdk24(
+    createGraphqlRequestClient(transport)
+  ).IssueRelationsGet({
+    owner: input.owner,
+    name: input.name,
+    issueNumber: input.issueNumber
+  });
+  const issue = asRecord(asRecord(asRecord(result)?.repository)?.issue);
+  const currentIssue = parseIssueRelationNode(issue);
+  if (!currentIssue) {
+    throw new Error("Issue relations not found");
+  }
+  const parent = parseIssueRelationNode(issue?.parent);
+  const subIssues = asRecord(issue?.["subIssues"]);
+  const blockedByConnection = asRecord(issue?.["blockedBy"]);
+  const childrenNodes = Array.isArray(subIssues?.["nodes"]) ? subIssues["nodes"] : [];
+  const blockedByNodes = Array.isArray(blockedByConnection?.["nodes"]) ? blockedByConnection["nodes"] : [];
+  return {
+    issue: currentIssue,
+    parent,
+    children: childrenNodes.map((node) => parseIssueRelationNode(node)).flatMap((node) => node ? [node] : []),
+    blockedBy: blockedByNodes.map((node) => parseIssueRelationNode(node)).flatMap((node) => node ? [node] : [])
+  };
+}
+async function runIssueParentSet(transport, input) {
+  assertIssueParentSetInput(input);
+  const result = await getSdk20(createGraphqlRequestClient(transport)).IssueParentSet({
+    issueId: input.issueId,
+    parentIssueId: input.parentIssueId
+  });
+  const mutation = asRecord(asRecord(result)?.addSubIssue);
+  const parentIssue = asRecord(mutation?.issue);
+  const subIssue = asRecord(mutation?.subIssue);
+  if (typeof parentIssue?.id !== "string" || typeof subIssue?.id !== "string") {
+    throw new Error("Issue parent update failed");
+  }
+  return {
+    issueId: subIssue.id,
+    parentIssueId: parentIssue.id,
+    updated: true
+  };
+}
+async function runIssueParentRemove(transport, input) {
+  assertIssueParentRemoveInput(input);
+  const client = createGraphqlRequestClient(transport);
+  const lookupResult = await getSdk18(client).IssueParentLookup({
+    issueId: input.issueId
+  });
+  const parentIssueId = asRecord(asRecord(asRecord(lookupResult)?.node)?.parent)?.id;
+  if (typeof parentIssueId !== "string" || parentIssueId.length === 0) {
+    throw new Error("Issue parent removal failed");
+  }
+  const result = await getSdk19(client).IssueParentRemove({
+    issueId: input.issueId,
+    parentIssueId
+  });
+  const mutation = asRecord(asRecord(result)?.removeSubIssue);
+  const parentIssue = asRecord(mutation?.issue);
+  const subIssue = asRecord(mutation?.subIssue);
+  if (typeof parentIssue?.id !== "string" || typeof subIssue?.id !== "string") {
+    throw new Error("Issue parent removal failed");
+  }
+  return {
+    issueId: subIssue.id,
+    parentRemoved: true
+  };
+}
+async function runIssueBlockedByAdd(transport, input) {
+  assertIssueBlockedByInput(input);
+  const result = await getSdk5(
+    createGraphqlRequestClient(transport)
+  ).IssueBlockedByAdd({
+    issueId: input.issueId,
+    blockedByIssueId: input.blockedByIssueId
+  });
+  const mutation = asRecord(asRecord(result)?.addBlockedBy);
+  const issue = asRecord(mutation?.issue);
+  const blockingIssue = asRecord(mutation?.blockingIssue);
+  if (typeof issue?.id !== "string" || typeof blockingIssue?.id !== "string") {
+    throw new Error("Issue dependency mutation failed");
+  }
+  return {
+    issueId: issue.id,
+    blockedByIssueId: blockingIssue.id,
+    added: true
+  };
+}
+async function runIssueBlockedByRemove(transport, input) {
+  assertIssueBlockedByInput(input);
+  const result = await getSdk6(
+    createGraphqlRequestClient(transport)
+  ).IssueBlockedByRemove({
+    issueId: input.issueId,
+    blockedByIssueId: input.blockedByIssueId
+  });
+  const mutation = asRecord(asRecord(result)?.removeBlockedBy);
+  const issue = asRecord(mutation?.issue);
+  const blockingIssue = asRecord(mutation?.blockingIssue);
+  if (typeof issue?.id !== "string" || typeof blockingIssue?.id !== "string") {
+    throw new Error("Issue dependency mutation failed");
+  }
+  return {
+    issueId: issue.id,
+    blockedByIssueId: blockingIssue.id,
+    removed: true
+  };
+}
+export {
+  runIssueAssigneesAdd,
+  runIssueAssigneesRemove,
+  runIssueAssigneesUpdate,
+  runIssueBlockedByAdd,
+  runIssueBlockedByRemove,
+  runIssueClose,
+  runIssueCommentCreate,
+  runIssueCreate,
+  runIssueDelete,
+  runIssueLabelsAdd,
+  runIssueLabelsUpdate,
+  runIssueLinkedPrsList,
+  runIssueMilestoneSet,
+  runIssueParentRemove,
+  runIssueParentSet,
+  runIssueRelationsGet,
+  runIssueReopen,
+  runIssueUpdate
+};
+//# sourceMappingURL=issue-mutations-FJNZW7L5.js.map