repo-starter-kit 0.2.0 → 0.3.0

package/lib/browser.d.ts

@@ -0,0 +1,7 @@
+import { type Failure, type Result } from '@zokugun/xtry';
+import { type Browser, type Page } from 'playwright';
+export type BrowserAction = (page: Page) => Promise<Failure<string> | undefined>;
+export declare function openBrowser(owner: string, repositoryName: string): Promise<Result<{
+    browser: Browser;
+    page: Page;
+}, string>>;

package/lib/browser.js

@@ -0,0 +1,86 @@
+import { err, ok, stringifyError } from '@zokugun/xtry';
+import enquirer from 'enquirer';
+import { chromium } from 'playwright';
+import * as logger from './utils/logger.js';
+export async function openBrowser(owner, repositoryName) {
+    let browser;
+    try {
+        browser = await chromium.launch({
+            headless: false,
+            channel: 'chrome',
+        });
+        const page = await browser.newPage();
+        await page.goto(`https://github.com/${owner}/${repositoryName}`, {
+            waitUntil: 'domcontentloaded',
+        });
+        await page.waitForLoadState('networkidle', { timeout: 1000 }).catch(() => undefined);
+        const signInExists = await hasSignInButton(page);
+        if (signInExists) {
+            logger.pause();
+            const confirmed = await waitForEnterWithTimeout(300_000, 'GitHub Sign in detected. Please login in Chrome, then press ENTER here within 5 minutes.');
+            if (!confirmed) {
+                return err('Timed out waiting for login confirmation (5 minutes).');
+            }
+            logger.resume();
+            const signInExists = await hasSignInButton(page);
+            if (signInExists) {
+                return err('GitHub Sign is still detected');
+            }
+        }
+        return ok({ browser, page });
+    }
+    catch (error) {
+        return err(`Failed to apply browser actions in Chrome (cross-platform): ${stringifyError(error)}`);
+    }
+}
+async function hasSignInButton(page) {
+    const signInLocators = [
+        () => page.getByRole('button', { name: 'Sign in', exact: true }).first(),
+        () => page.getByRole('link', { name: 'Sign in', exact: true }).first(),
+        () => page.getByText('Sign in', { exact: true }).first(),
+    ];
+    for (const createLocator of signInLocators) {
+        try {
+            if (await createLocator().count() > 0) {
+                return true;
+            }
+        }
+        catch { }
+    }
+    return false;
+}
+async function waitForEnterWithTimeout(timeoutMilliseconds, message) {
+    let timeoutId;
+    const promptPromise = enquirer
+        .prompt({
+        type: 'invisible',
+        name: 'open',
+        message,
+    })
+        // eslint-disable-next-line promise/prefer-await-to-then
+        .then(() => {
+        clearTimeout(timeoutId);
+        return true;
+    })
+        // eslint-disable-next-line promise/prefer-await-to-then
+        .catch(() => {
+        clearTimeout(timeoutId);
+        return false;
+    });
+    const timeoutPromise = new Promise((resolve) => {
+        timeoutId = setTimeout(() => resolve(false), timeoutMilliseconds);
+    });
+    return Promise.race([promptPromise, timeoutPromise]);
+}
+// function resolveChromeUserDataDir(): string | undefined {
+// 	if(process.env.CHROME_USER_DATA_DIR) {
+// 		return process.env.CHROME_USER_DATA_DIR;
+// 	}
+// 	if(process.platform === 'darwin') {
+// 		return `${process.env.HOME}/Library/Application Support/Google/Chrome`;
+// 	}
+// 	if(process.platform === 'win32') {
+// 		return process.env.LOCALAPPDATA ? `${process.env.LOCALAPPDATA}\\Google\\Chrome\\User Data` : undefined;
+// 	}
+// 	return `${process.env.HOME}/.config/google-chrome`;
+// }

package/lib/categories/load-categories.d.ts

@@ -0,0 +1,3 @@
+import { type Result } from '@zokugun/xtry';
+import { type Category } from '../types.js';
+export declare function loadCategories(filename: string): Promise<Result<Category[], string>>;

package/lib/categories/load-categories.js

@@ -0,0 +1,32 @@
+import { readFile } from 'node:fs/promises';
+import { isRecord } from '@zokugun/is-it-type';
+import { err, ok, stringifyError } from '@zokugun/xtry';
+import YAML from 'yaml';
+export async function loadCategories(filename) {
+    let content;
+    try {
+        content = await readFile(filename, 'utf8');
+    }
+    catch (error) {
+        return err(`Failed to read ${filename} from package: ${stringifyError(error)}`);
+    }
+    const records = YAML.parse(content);
+    if (!Array.isArray(records)) {
+        return err(`Category file ${filename} must contain an array.`);
+    }
+    const categories = [];
+    for (const [index, record] of records.entries()) {
+        if (!isRecord(record)) {
+            return err(`Category entry at index ${index} must be an object.`);
+        }
+        const name = String(record.name ?? '').trim();
+        const description = String(record.description ?? '').trim();
+        const emoji = String(record.emoji ?? '').trim();
+        const format = record.format === 'announcement' || record.format === 'answer' || record.format === 'poll' ? record.format : 'open';
+        if (name.length === 0) {
+            return err(`Category entry at index ${index} must define a non-empty 'name'.`);
+        }
+        categories.push({ name, description, emoji, format });
+    }
+    return ok(categories);
+}

package/lib/categories/sync-categories.d.ts

@@ -0,0 +1,3 @@
+import { type Failure } from '@zokugun/xtry';
+import { type Context, type Category } from '../types.js';
+export declare function syncCategories(context: Context, categories: Category[], keepExisting?: boolean): Promise<Failure<string> | undefined>;

package/lib/categories/sync-categories.js

@@ -0,0 +1,182 @@
+import { err, stringifyError } from '@zokugun/xtry';
+import * as logger from '../utils/logger.js';
+import { openPage } from '../utils/open-page.js';
+export async function syncCategories(context, categories, keepExisting = false) {
+    if (categories.length === 0) {
+        logger.warn('No categories defined; skipping category sync.');
+        return;
+    }
+    try {
+        const response = await context.octokit.graphql(`query listCategories($owner: String!, $name: String!) {
+				repository(owner: $owner, name: $name) {
+					discussionCategories(first: 25) {
+						totalCount
+
+						pageInfo {
+							startCursor
+							endCursor
+							hasNextPage
+							hasPreviousPage
+						}
+
+						edges {
+							cursor
+
+							node {
+								name
+								description
+								emoji
+							}
+						}
+					}
+				}
+			}`, {
+            owner: context.owner,
+            name: context.repositoryName,
+        });
+        const currentCategories = [];
+        for (const edge of response.repository.discussionCategories.edges) {
+            currentCategories.push(edge.node);
+        }
+        const openResult = await openPage(context);
+        if (openResult.fails) {
+            return openResult;
+        }
+        const page = openResult.value;
+        await page.goto(`https://github.com/${context.owner}/${context.repositoryName}/discussions/categories`, {
+            waitUntil: 'domcontentloaded',
+        });
+        await page.waitForLoadState('networkidle', { timeout: 1000 }).catch(() => undefined);
+        const items = await page.locator('li[data-view-component=true]').all();
+        for (const item of items) {
+            const header = item.locator('h2').first();
+            const title = await header.textContent();
+            if (!title) {
+                continue;
+            }
+            const name = title.trim();
+            const match = currentCategories.filter((category) => name === category.name);
+            if (match) {
+                const icons = await header.locator('svg[aria-label="Restricted"]').count();
+                if (icons === 0) {
+                    const answers = await item.getByText('Answers enabled').count();
+                    if (answers === 0) {
+                        match[0].format = 'open';
+                    }
+                    else {
+                        match[0].format = 'answer';
+                    }
+                }
+                else {
+                    match[0].format = 'announcement';
+                }
+                const href = await item.locator('a').first().getAttribute('href');
+                if (!href) {
+                    continue;
+                }
+                const result = /\/(\d+)\/edit/.exec(href);
+                if (result) {
+                    match[0].id = result[1];
+                }
+            }
+        }
+        const desiredNames = new Set();
+        for (const category of categories) {
+            desiredNames.add(category.name);
+            const match = currentCategories.filter(({ name }) => name === category.name);
+            if (match.length === 0) {
+                await createCategory(context, category);
+            }
+            else {
+                const current = match[0];
+                if (category.description !== current.description || category.emoji !== current.emoji || category.format !== current.format) {
+                    await updateCategory(context, category, current.id);
+                }
+            }
+        }
+        if (keepExisting) {
+            logger.log('Keeping existing categories that are not in the configuration.');
+            return;
+        }
+        await deleteMissings(context, currentCategories, desiredNames);
+    }
+    catch (error) {
+        logger.error(stringifyError(error));
+        console.log(error);
+        return err(stringifyError(error));
+    }
+} // }}}
+async function deleteMissings(context, existings, desiredNames) {
+    for (const existing of existings) {
+        if (!desiredNames.has(existing.name)) {
+            await deleteCategory(context, existing);
+        }
+    }
+} // }}}
+async function createCategory({ page, owner, repositoryName }, category) {
+    logger.log(`Creating category: ${category.name}`);
+    await page.goto(`https://github.com/${owner}/${repositoryName}/discussions/categories/new`, {
+        waitUntil: 'domcontentloaded',
+    });
+    await page.waitForLoadState('networkidle', { timeout: 1000 }).catch(() => undefined);
+    await page.locator('#category\\[name\\]').first().fill(category.name);
+    await page.locator('#category\\[description\\]').first().fill(category.description ?? '');
+    if (category.emoji) {
+        await page.locator('input[type=hidden][name*=emoji]').evaluate((element, value) => {
+            element.value = value;
+        }, category.emoji);
+    }
+    if (category.format === 'announcement') {
+        await page.locator('#supports_announcements_true_discussion_category').first().check();
+    }
+    else if (category.format === 'answer') {
+        await page.locator('#supports_mark_as_answer_true_discussion_category').first().check();
+    }
+    else if (category.format === 'poll') {
+        await page.locator('#supports_polls_true_discussion_category').first().check();
+    }
+    else {
+        await page.locator('#supports_mark_as_answer_false_discussion_category').first().check();
+    }
+    await page.locator('button.Button--primary[type=submit]').first().click();
+    await page.waitForLoadState('networkidle', { timeout: 1000 }).catch(() => undefined);
+}
+async function updateCategory({ page, owner, repositoryName }, category, id) {
+    logger.log(`Updating category: ${category.name}`);
+    await page.goto(`https://github.com/${owner}/${repositoryName}/discussions/categories/${id}/edit`, {
+        waitUntil: 'domcontentloaded',
+    });
+    await page.waitForLoadState('networkidle', { timeout: 1000 }).catch(() => undefined);
+    await page.locator('#category\\[name\\]').first().fill(category.name);
+    await page.locator('#category\\[description\\]').first().fill(category.description ?? '');
+    if (category.emoji) {
+        await page.locator('input[type=hidden][name*=emoji]').evaluate((element, value) => {
+            element.value = value;
+        }, category.emoji);
+    }
+    if (category.format === 'announcement') {
+        await page.locator(`#supports_announcements_true_discussion_category_${id}`).first().check();
+    }
+    else if (category.format === 'answer') {
+        await page.locator(`#supports_mark_as_answer_true_discussion_category_${id}`).first().check();
+    }
+    else if (category.format === 'poll') {
+        await page.locator(`#supports_polls_true_discussion_category_${id}`).first().check();
+    }
+    else {
+        await page.locator(`#supports_mark_as_answer_false_discussion_category_${id}`).first().check();
+    }
+    await page.locator('button.Button--primary[type=submit]').first().click();
+    await page.waitForLoadState('networkidle', { timeout: 1000 }).catch(() => undefined);
+}
+async function deleteCategory({ page, owner, repositoryName }, category) {
+    logger.log(`Deleting category: ${category.name}`);
+    await page.goto(`https://github.com/${owner}/${repositoryName}/discussions/categories`, {
+        waitUntil: 'domcontentloaded',
+    });
+    await page.waitForLoadState('networkidle', { timeout: 1000 }).catch(() => undefined);
+    const form = page.locator(`form[action="/${owner}/${repositoryName}/discussions/categories/${category.id}"]`).first();
+    await form.locator('button.Button--link').first().click();
+    await form.locator('button.btn-danger').first().click();
+    await page.waitForLoadState('networkidle', { timeout: 1000 }).catch(() => undefined);
+}

package/lib/cli.js

@@ -7,11 +7,7 @@ program
     .description(pkg.description)
     .requiredOption('-r, --repo <owner/name>', 'Target repository (OWNER/NAME)')
     .option('-c, --create', 'Create the repository if it does not exist', false)
-    .option('-l, --labels <path>', 'Path to labels YAML')
-    .option('-i, --issue <path>', 'Path to issue Markdown template')
-    .option('-b, --rulesets <path>', 'Path to branch rulesets YAML/JSON file')
     .option('-p, --package <name>', 'NPM package that includes a repo-starter-kit config file')
-    .option('--keep-labels', 'Do not delete labels missing from the configuration', false)
-    .option('--keep-rulesets', 'Do not delete rulesets missing from the configuration', false)
+    .option('-k, --keep', 'Do not delete missing items (labels, categories, rulesets)', false)
     .action(run);
 program.parse();

package/lib/config/load-package-config.d.ts

@@ -1,9 +1,3 @@
-import { type Result } from '@zokugun/xtry';
-type Config = {
-    root: string;
-    labels?: string;
-    issue?: string;
-    rulesets?: string[];
-};
+import { type Result } from '@zokugun/xtry/sync';
+import { type Config } from '../types.js';
 export declare function loadConfig(value: string): Promise<Result<Config, string>>;
-export {};

package/lib/config/load-package-config.js

@@ -1,15 +1,13 @@
-import { readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { err, ok, stringifyError, xtry, yerr, yress } from '@zokugun/xtry';
-import fse from 'fs-extra';
+import fse from '@zokugun/fs-extra-plus/async';
+import { isArray, isEquals, isNonBlankString, isRecord } from '@zokugun/is-it-type';
+import { err, ok, stringifyError, xtry, yerr, yres } from '@zokugun/xtry/sync';
 import YAML from 'yaml';
 import { downloadPackage } from '../npms/download-package.js';
 import { normalizePackageName } from '../npms/normalize-package-name.js';
 import { splitNpmPath } from '../npms/split-npm-ath.js';
 import { joinWithinRoot } from '../paths/join-within-root.js';
 import { resolveLocalPath } from '../paths/resolve-local-path.js';
-import { isNodeError } from '../utils/is-node-error.js';
-import { isRecord } from '../utils/is-record.js';
 const CONFIG_FILES = [
     {
         name: 'repo-starter-kit.yml',
@@ -57,7 +55,10 @@ export async function loadConfig(value) {
 } // }}}
 async function readConfigFromPackage(packageRoot, packageName) {
     const stat = await fse.stat(packageRoot);
-    if (stat.isFile()) {
+    if (stat.fails) {
+        return err(stringifyError(stat.error));
+    }
+    if (stat.value.isFile()) {
         const result = await tryReadConfigFile(packageRoot, path.dirname(packageRoot), path.basename(packageRoot));
         if (result.fails || result.success) {
             return result;
@@ -74,24 +75,27 @@ async function readConfigFromPackage(packageRoot, packageName) {
     return err(`Package ${packageName} must include one of ${CONFIG_FILES.map(({ name }) => name).join(', ')} at its root.`);
 } // }}}
 async function tryReadConfigFile(filename, root, name, type) {
-    try {
-        const content = await readFile(filename, 'utf8');
+    const { fails, error, value: content } = await fse.readFile(filename, 'utf8');
+    if (fails) {
+        if (error.code === 'ENOENT') {
+            return yerr('not-found');
+        }
+        return err(`Failed to read ${name} from package: ${stringifyError(error)}`);
+    }
+    else {
         const parsed = parseConfigContent(content, type);
         if (parsed.fails) {
             return err(`Failed to parse ${name} from package: ${parsed.error}`);
         }
-        return yress(normalizeConfig(parsed.value, root, name));
-    }
-    catch (error) {
-        if (isNodeError(error) && error.code === 'ENOENT') {
-            return yerr('not-found');
-        }
-        return err(`Failed to read ${name} from package: ${stringifyError(error)}`);
+        return yres(normalizeConfig(parsed.value, root, name));
     }
 } // }}}
 async function readConfigFromLocal(fileRoot) {
     const stat = await fse.stat(fileRoot);
-    if (stat.isFile()) {
+    if (stat.fails) {
+        return err(stringifyError(stat.error));
+    }
+    if (stat.value.isFile()) {
         const result = await tryReadConfigFile(fileRoot, path.dirname(fileRoot), path.basename(fileRoot));
         if (result.fails || result.success) {
             return result;
@@ -124,19 +128,30 @@ function normalizeConfig(data, root, source) {
     if (!isRecord(data)) {
         return err(`Config file ${source} must export an object.`);
     }
-    const labels = typeof data.labels === 'string' ? data.labels : undefined;
-    const issue = typeof data.issue === 'string' ? data.issue : undefined;
+    const categories = isNonBlankString(data.categories) ? data.categories : undefined;
+    const discussion = isNonBlankString(data.discussion) ? data.discussion : undefined;
+    const labels = isNonBlankString(data.labels) ? data.labels : undefined;
+    const newRepository = isNonBlankString(data.newRepository) ? data.newRepository : undefined;
+    const issue = isNonBlankString(data.issue) ? data.issue : undefined;
     let rulesets;
-    if (typeof data.rulesets === 'string') {
+    if (isNonBlankString(data.rulesets)) {
         rulesets = [data.rulesets];
     }
-    else if (Array.isArray(data.rulesets) && data.rulesets.every((ruleset) => typeof ruleset === 'string')) {
+    else if (isArray(data.rulesets, isNonBlankString)) {
         rulesets = data.rulesets;
     }
+    let order;
+    if (isArray(data.order, (item) => isEquals(item, 'discussion', 'issue'))) {
+        order = data.order;
+    }
     return ok({
         root,
-        labels,
+        categories,
+        discussion,
         issue,
+        labels,
+        newRepository,
         rulesets,
+        order,
     });
 } // }}}

package/lib/discussions/create-discussion.d.ts

@@ -0,0 +1,3 @@
+import { type Failure } from '@zokugun/xtry';
+import { type Context, type Discussion } from '../types.js';
+export declare function createDiscussion(context: Context, { title, body, category, labels, close, pin, lock }: Discussion): Promise<Failure<string> | undefined>;

package/lib/discussions/create-discussion.js

@@ -0,0 +1,127 @@
+import { err, stringifyError } from '@zokugun/xtry';
+import * as logger from '../utils/logger.js';
+import { openPage } from '../utils/open-page.js';
+export async function createDiscussion(context, { title, body, category, labels, close, pin, lock }) {
+    const { octokit, owner, repositoryName, repositoryId } = context;
+    try {
+        logger.log(`Creating discussion '${title}'`);
+        const categories = await octokit.graphql(`query listCategories($owner: String!, $name: String!) {
+				repository(owner: $owner, name: $name) {
+					discussionCategories(first: 25) {
+						totalCount
+
+						pageInfo {
+							startCursor
+							endCursor
+							hasNextPage
+							hasPreviousPage
+						}
+
+						edges {
+							cursor
+
+							node {
+								id
+								name
+							}
+						}
+					}
+				}
+			}`, {
+            owner,
+            name: repositoryName,
+        });
+        const categoryId = categories.repository.discussionCategories.edges.filter(({ node }) => node.name === category).map(({ node }) => node.id)[0];
+        if (!categoryId) {
+            return err(`Cannot find category "${category}"`);
+        }
+        const response = await octokit.graphql(`mutation createDiscussion($repositoryId: ID!, $categoryId: ID!, $title: String!, $body: String!) {
+				createDiscussion(input: {repositoryId: $repositoryId, categoryId: $categoryId, title: $title, body: $body}) {
+					discussion {
+						id
+						number
+					}
+				}
+			}`, {
+            repositoryId,
+            categoryId,
+            title,
+            body,
+        });
+        const discussionId = response.createDiscussion.discussion.id;
+        const discussionNumber = response.createDiscussion.discussion.number;
+        if (labels.length > 0) {
+            logger.log(`Adding labels to discussion '${title}'`);
+            const labelsForRepo = await octokit.rest.issues.listLabelsForRepo({
+                owner,
+                repo: repositoryName,
+            });
+            const labelIds = [];
+            for (const name of labels) {
+                const label = labelsForRepo.data.filter((label) => label.name === name);
+                if (label.length > 0) {
+                    labelIds.push(label[0].node_id);
+                }
+            }
+            await octokit.graphql(`mutation addLabels($discussionId: ID!, $labelIds: [ID!]!) {
+					addLabelsToLabelable(input: {labelableId: $discussionId, labelIds: $labelIds}) {
+						labelable {
+							... on Discussion {
+								id
+							}
+						}
+					}
+				}`, {
+                discussionId,
+                labelIds,
+            });
+        }
+        if (close) {
+            logger.log(`Closing discussion '${title}'`);
+            const reason = close === 'resolved' ? 'RESOLVED' : 'OUTDATED';
+            await octokit.graphql(`mutation closeDiscussion($discussionId: ID!, $reason: DiscussionCloseReason!) {
+					closeDiscussion(input: {discussionId: $discussionId, reason: $reason}) {
+						discussion {
+							id
+							closed
+						}
+					}
+				}`, {
+                discussionId,
+                reason,
+            });
+        }
+        if (lock) {
+            logger.log(`Locking discussion '${title}'`);
+            await octokit.graphql(`mutation lockDiscussion($discussionId: ID!) {
+					lockLockable(input: {lockableId: $discussionId}) {
+						lockedRecord {
+							locked
+						}
+					}
+				}`, {
+                discussionId,
+            });
+        }
+        if (pin) {
+            logger.log(`Pinning discussion '${title}'`);
+            const openResult = await openPage(context);
+            if (openResult.fails) {
+                return openResult;
+            }
+            const page = openResult.value;
+            await page.goto(`https://github.com/${owner}/${repositoryName}/discussions/${discussionNumber}`, {
+                waitUntil: 'domcontentloaded',
+            });
+            await page.waitForLoadState('networkidle', { timeout: 1000 }).catch(() => undefined);
+            await page.locator('#dialog-show-discussion-create-spotlight').first().click();
+            await page.locator('#discussion_spotlight_preconfigured_color_green').first().check();
+            await page.locator('button.Button--primary[type=submit]').getByText('Pin discussion').first().click();
+            await page.waitForLoadState('networkidle', { timeout: 1000 }).catch(() => undefined);
+        }
+        logger.log(`Created discussion '${title}' (#${discussionNumber}).`);
+    }
+    catch (error) {
+        return err(stringifyError(error));
+    }
+}

package/lib/discussions/load-discussion.d.ts

@@ -0,0 +1,3 @@
+import { type Result } from '@zokugun/xtry';
+import { type Discussion } from '../types.js';
+export declare function loadDiscussion(filename: string): Promise<Result<Discussion, string>>;

package/lib/discussions/load-discussion.js

@@ -0,0 +1,29 @@
+import { readFile } from 'node:fs/promises';
+import { isArray, isBoolean, isEquals, isNonBlankString } from '@zokugun/is-it-type';
+import { err, ok, stringifyError } from '@zokugun/xtry';
+import matter from 'gray-matter';
+export async function loadDiscussion(filename) {
+    let content;
+    try {
+        content = await readFile(filename, 'utf8');
+    }
+    catch (error) {
+        return err(`Failed to read ${filename} from package: ${stringifyError(error)}`);
+    }
+    const parsed = matter(content);
+    const title = isNonBlankString(parsed.data.title) ? parsed.data.title.trim() : '';
+    const category = isNonBlankString(parsed.data.category) ? parsed.data.category.trim() : '';
+    if (title.length === 0) {
+        return err(`Missing title in ${filename}`);
+    }
+    if (category.length === 0) {
+        return err(`Missing category in ${filename}`);
+    }
+    const rawLabels = isArray(parsed.data.labels) ? parsed.data.labels : [];
+    const labels = rawLabels.map((label) => String(label).trim()).filter((label) => label.length > 0);
+    const close = isEquals(parsed.data.close, 'resolved', 'outdated') ? parsed.data.close : undefined;
+    const pin = isBoolean(parsed.data.pin) ? parsed.data.pin : undefined;
+    const lock = isBoolean(parsed.data.lock) ? parsed.data.lock : undefined;
+    const body = parsed.content;
+    return ok({ title, body, category, labels, close, pin, lock });
+}

package/lib/issues/create-issue.d.ts

@@ -1,4 +1,3 @@
-import { type Octokit } from '@octokit/rest';
 import { type Failure } from '@zokugun/xtry';
-import { type Issue, type RepoReference } from '../types.js';
-export declare function createIssue(octokit: Octokit, repo: RepoReference, { title, body, labels }: Issue): Promise<Failure<string> | undefined>;
+import { type Context, type Issue } from '../types.js';
+export declare function createIssue(context: Context, { title, body, labels, close, pin, lock }: Issue): Promise<Failure<string> | undefined>;