@kici-dev/sdk 0.0.0 → 0.1.1

package/dist/secrets.js

@@ -0,0 +1,132 @@
+import "./chunk-gOLHoazu.js";
+import { SecretNotFoundError } from "./errors.js";
+//#region src/secrets.ts
+/**
+* Create a StepSecrets instance backed by a plain secrets map.
+* The env parameter receives exposed secrets via expose().
+* Tracks which secrets are accessed for audit/observability purposes.
+*
+* @param secretsMap - Flat key-value secrets map
+* @param env - Process environment to inject exposed secrets into
+* @param metaMap - Optional metadata map from resolveForJobWithMeta (backend + scope per key)
+* @param fileWiring - Optional file-mount host adapter. When omitted, `mountFile`
+*   and `exposeFile` throw -- callers that don't wire a host can still use the
+*   string-only `get` / `expose` / `has` / `list` surface.
+*/
+function createStepSecrets(secretsMap, env, metaMap, fileWiring) {
+	const accessed = /* @__PURE__ */ new Set();
+	const mountedKeys = /* @__PURE__ */ new Set();
+	const mountRecords = [];
+	function assertFileWiring(method) {
+		if (!fileWiring) throw new Error(`ctx.secrets.${method}() requires a file-mount host. The current secrets runtime did not wire one in (e.g. you may be running outside the agent or local-test mode).`);
+		return fileWiring;
+	}
+	async function buildContent(opts) {
+		const sources = opts.sources;
+		if (!Array.isArray(sources) || sources.length === 0) throw new Error("mountFile(): \"sources\" must be a non-empty array of secret keys");
+		const missing = [];
+		const parts = [];
+		for (const key of sources) {
+			if (!(key in secretsMap)) {
+				missing.push(key);
+				continue;
+			}
+			parts.push(secretsMap[key]);
+		}
+		if (missing.length > 0) {
+			const err = new SecretNotFoundError(missing[0], Object.keys(secretsMap));
+			if (missing.length > 1) err.message = `Secrets ${missing.map((k) => `"${k}"`).join(", ")} not found. Available keys: ${Object.keys(secretsMap).join(", ") || "(none)"}.`;
+			throw err;
+		}
+		for (const key of sources) {
+			accessed.add(key);
+			mountedKeys.add(key);
+		}
+		const divider = opts.divider ?? "";
+		return {
+			content: parts.join(divider),
+			sources: [...sources]
+		};
+	}
+	return {
+		secrets: {
+			async get(key) {
+				if (!(key in secretsMap)) throw new SecretNotFoundError(key, Object.keys(secretsMap));
+				accessed.add(key);
+				return secretsMap[key];
+			},
+			async expose(key) {
+				if (!(key in secretsMap)) throw new SecretNotFoundError(key, Object.keys(secretsMap));
+				accessed.add(key);
+				env[key] = secretsMap[key];
+			},
+			has(key) {
+				return key in secretsMap;
+			},
+			getMeta(key) {
+				if (!metaMap || !(key in metaMap)) return void 0;
+				return metaMap[key];
+			},
+			list() {
+				return Object.keys(secretsMap).sort();
+			},
+			async mountFile(opts) {
+				const wiring = assertFileWiring("mountFile");
+				const { content, sources } = await buildContent(opts);
+				const path = await wiring.host.writeMountedFile({
+					content,
+					sources,
+					mode: opts.mode ?? 384,
+					name: opts.name
+				});
+				mountRecords.push({
+					sources,
+					target: path,
+					kind: "mountFile"
+				});
+				return { path };
+			},
+			async exposeFile(envVar, opts) {
+				if (typeof envVar !== "string" || envVar.length === 0) throw new Error("exposeFile(): \"envVar\" must be a non-empty string");
+				const wiring = assertFileWiring("exposeFile");
+				const { content, sources } = await buildContent(opts);
+				const path = await wiring.host.writeMountedFile({
+					content,
+					sources,
+					mode: opts.mode ?? 384,
+					name: opts.name
+				});
+				env[envVar] = path;
+				wiring.host.trackExposedEnv(envVar);
+				mountRecords.push({
+					sources,
+					target: path,
+					envVar,
+					kind: "exposeFile"
+				});
+				return { path };
+			},
+			getAccessLog() {
+				return [...accessed].sort();
+			},
+			getMountedKeys() {
+				return [...mountedKeys].sort();
+			},
+			getMountRecords() {
+				return mountRecords;
+			}
+		},
+		dispose: async () => {
+			if (!fileWiring) return;
+			try {
+				await fileWiring.cleanup();
+			} catch (err) {
+				fileWiring.onDisposeError?.(err);
+			}
+		}
+	};
+}
+//#endregion
+export { createStepSecrets };
+
+//# sourceMappingURL=secrets.js.map

package/dist/step.d.ts

@@ -0,0 +1,50 @@
+import type { Step, StepOptions, StepRunFn } from './types.js';
+/**
+ * Create an id-less step with just a run function.
+ * The compiler assigns a counter-based ID (step-1, step-2, etc.) at lock file generation.
+ *
+ * @example
+ * const s = step(async (ctx) => {
+ *   await ctx.$`echo hello`;
+ * });
+ */
+export declare function step<TResult = void>(run: (ctx: import('./context.js').StepContext) => Promise<TResult>): Step<TResult>;
+/**
+ * Create an id-less step with full options.
+ * The compiler assigns a counter-based ID at lock file generation.
+ *
+ * @example
+ * const s = step({
+ *   run: async (ctx) => {
+ *     return { version: '1.0.0' };
+ *   },
+ *   timeout: 60000,
+ * });
+ */
+export declare function step<TResult = void>(options: StepOptions<TResult>): Step<TResult>;
+/**
+ * Create a named step with just a run function (no outputs).
+ *
+ * @example
+ * const checkout = step('checkout', async (ctx) => {
+ *   await ctx.$`git checkout`;
+ * });
+ */
+export declare function step(name: string, run: StepRunFn): Step<void>;
+/**
+ * Create a named step with full options and generic return type.
+ *
+ * @example
+ * const build = step('build', {
+ *   outputs: {
+ *     version: z.string(),
+ *     artifacts: z.array(z.string()),
+ *   },
+ *   run: async (ctx) => {
+ *     await ctx.$`pnpm build`;
+ *     return { version: '1.0.0', artifacts: ['dist/main.js'] };
+ *   }
+ * });
+ */
+export declare function step<TResult = void>(name: string, options: StepOptions<TResult>): Step<TResult>;
+//# sourceMappingURL=step.d.ts.map

package/dist/step.js

@@ -0,0 +1,78 @@
+import "./chunk-gOLHoazu.js";
+import { createStepOutputProxy } from "./outputs.js";
+//#region src/step.ts
+/**
+* Capture the call-site source location of step() using the V8 stack trace API.
+* Uses Error.captureStackTrace with the `step` function as the constructor argument
+* so the stack starts from step()'s caller.
+*
+* @returns SourceLocation or undefined if parsing fails
+*/
+function captureCallSite() {
+	const originalLimit = Error.stackTraceLimit;
+	try {
+		Error.stackTraceLimit = 4;
+		const err = {};
+		Error.captureStackTrace(err, captureCallSite);
+		const stack = err.stack;
+		if (!stack) return void 0;
+		const lines = stack.split("\n");
+		for (let i = 2; i < lines.length; i++) {
+			const line = lines[i].trim();
+			const match = line.match(/\((.+):(\d+):(\d+)\)$/) || line.match(/^at (.+):(\d+):(\d+)$/);
+			if (match) {
+				let file = match[1];
+				if (file.startsWith("file://")) file = file.slice(7);
+				return {
+					file,
+					line: parseInt(match[2], 10),
+					column: parseInt(match[3], 10)
+				};
+			}
+		}
+		return;
+	} catch {
+		return;
+	} finally {
+		Error.stackTraceLimit = originalLimit;
+	}
+}
+/**
+* Implementation of step() factory.
+* Discriminates overloads by first arg type:
+* - string => named variant (existing)
+* - function => id-less simple (wrap as { run: fn }, name = '')
+* - object => id-less full options (name = '')
+*/
+function step(nameOrRunOrOptions, runOrOptions) {
+	const _sourceLocation = captureCallSite();
+	let name;
+	let options;
+	if (typeof nameOrRunOrOptions === "string") {
+		name = nameOrRunOrOptions;
+		options = typeof runOrOptions === "function" ? { run: runOrOptions } : runOrOptions;
+	} else if (typeof nameOrRunOrOptions === "function") {
+		name = "";
+		options = { run: nameOrRunOrOptions };
+	} else {
+		name = "";
+		options = nameOrRunOrOptions;
+	}
+	return {
+		_tag: "Step",
+		name,
+		outputs: options.outputs,
+		run: options.run,
+		continueOnError: options.continueOnError,
+		timeout: options.timeout,
+		rules: options.rules,
+		onCancel: options.onCancel,
+		cleanup: options.cleanup,
+		_sourceLocation,
+		result: createStepOutputProxy(name)
+	};
+}
+//#endregion
+export { step };
+
+//# sourceMappingURL=step.js.map

package/dist/triggers/comment.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Comment trigger helper - creates triggers for issue/PR comment events.
+ * Returns a frozen CommentTriggerConfig directly.
+ */
+import type { CommentConfigInput, CommentTriggerConfig } from './types.js';
+/**
+ * Create a comment trigger configuration.
+ *
+ * @example
+ * // Match any comment
+ * comment()
+ *
+ * // Match deploy commands
+ * comment({ bodyMatch: '/deploy' })
+ *
+ * // Match with regex
+ * comment({ bodyMatch: /^\/deploy/i, source: 'pr' })
+ */
+export declare function comment(config?: CommentConfigInput): CommentTriggerConfig;
+//# sourceMappingURL=comment.d.ts.map

package/dist/triggers/comment.js

@@ -0,0 +1,47 @@
+import "../chunk-gOLHoazu.js";
+import { asArray, toBranchPattern } from "./types.js";
+//#region src/triggers/comment.ts
+/**
+* Convert a string or RegExp to a BodyMatchPattern.
+* Strings become glob patterns, RegExp becomes regex patterns.
+*/
+function toBodyMatchPattern(input) {
+	if (input instanceof RegExp) return {
+		type: "regex",
+		pattern: input.source,
+		flags: input.flags || void 0
+	};
+	return {
+		type: "glob",
+		pattern: input
+	};
+}
+/**
+* Create a comment trigger configuration.
+*
+* @example
+* // Match any comment
+* comment()
+*
+* // Match deploy commands
+* comment({ bodyMatch: '/deploy' })
+*
+* // Match with regex
+* comment({ bodyMatch: /^\/deploy/i, source: 'pr' })
+*/
+function comment(config) {
+	const repos = config?.repos ? asArray(config.repos).map(toBranchPattern) : [];
+	const result = {
+		_tag: "CommentTrigger",
+		actions: Object.freeze(config?.actions ? [...config.actions] : []),
+		...config?.source !== void 0 && { source: config.source },
+		...config?.bodyMatch !== void 0 && { bodyMatch: toBodyMatchPattern(config.bodyMatch) },
+		repos: Object.freeze([...repos]),
+		...config?.description !== void 0 && { description: config.description }
+	};
+	return Object.freeze(result);
+}
+//#endregion
+export { comment };
+
+//# sourceMappingURL=comment.js.map

package/dist/triggers/create.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Create trigger helper - creates triggers for ref creation events (branches/tags).
+ * Returns a frozen CreateTriggerConfig directly.
+ */
+import type { CreateConfigInput, CreateTriggerConfig } from './types.js';
+/**
+ * Create a ref creation trigger configuration.
+ *
+ * @example
+ * // Match any ref creation
+ * create()
+ *
+ * // Match tag creation with patterns
+ * create({ refTypes: ['tag'], patterns: ['v*'] })
+ *
+ * // Match branch creation
+ * create({ refTypes: ['branch'], patterns: ['release/*'] })
+ */
+export declare function create(config?: CreateConfigInput): CreateTriggerConfig;
+//# sourceMappingURL=create.d.ts.map

package/dist/triggers/create.js

@@ -0,0 +1,32 @@
+import "../chunk-gOLHoazu.js";
+import { asArray, toBranchPattern } from "./types.js";
+//#region src/triggers/create.ts
+/**
+* Create a ref creation trigger configuration.
+*
+* @example
+* // Match any ref creation
+* create()
+*
+* // Match tag creation with patterns
+* create({ refTypes: ['tag'], patterns: ['v*'] })
+*
+* // Match branch creation
+* create({ refTypes: ['branch'], patterns: ['release/*'] })
+*/
+function create(config) {
+	const patterns = config?.patterns ? asArray(config.patterns).map(toBranchPattern) : [];
+	const repos = config?.repos ? asArray(config.repos).map(toBranchPattern) : [];
+	const result = {
+		_tag: "CreateTrigger",
+		refTypes: Object.freeze(config?.refTypes ? [...config.refTypes] : []),
+		patterns: Object.freeze([...patterns]),
+		repos: Object.freeze([...repos]),
+		...config?.description !== void 0 && { description: config.description }
+	};
+	return Object.freeze(result);
+}
+//#endregion
+export { create };
+
+//# sourceMappingURL=create.js.map

package/dist/triggers/delete.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Delete trigger helper - creates triggers for ref deletion events (branches/tags).
+ * Returns a frozen DeleteTriggerConfig directly.
+ *
+ * Note: `delete` is a reserved word in JavaScript, so the internal function
+ * is named `del` and re-exported as `delete` from index.ts.
+ */
+import type { DeleteConfigInput, DeleteTriggerConfig } from './types.js';
+/**
+ * Create a ref deletion trigger configuration.
+ *
+ * @example
+ * // Match any ref deletion
+ * del()
+ *
+ * // Match tag deletion
+ * del({ refTypes: ['tag'], patterns: ['v*'] })
+ */
+export declare function del(config?: DeleteConfigInput): DeleteTriggerConfig;
+//# sourceMappingURL=delete.d.ts.map

package/dist/triggers/delete.js

@@ -0,0 +1,29 @@
+import "../chunk-gOLHoazu.js";
+import { asArray, toBranchPattern } from "./types.js";
+//#region src/triggers/delete.ts
+/**
+* Create a ref deletion trigger configuration.
+*
+* @example
+* // Match any ref deletion
+* del()
+*
+* // Match tag deletion
+* del({ refTypes: ['tag'], patterns: ['v*'] })
+*/
+function del(config) {
+	const patterns = config?.patterns ? asArray(config.patterns).map(toBranchPattern) : [];
+	const repos = config?.repos ? asArray(config.repos).map(toBranchPattern) : [];
+	const result = {
+		_tag: "DeleteTrigger",
+		refTypes: Object.freeze(config?.refTypes ? [...config.refTypes] : []),
+		patterns: Object.freeze([...patterns]),
+		repos: Object.freeze([...repos]),
+		...config?.description !== void 0 && { description: config.description }
+	};
+	return Object.freeze(result);
+}
+//#endregion
+export { del };
+
+//# sourceMappingURL=delete.js.map

package/dist/triggers/dispatch.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Dispatch trigger helper - creates triggers for repository_dispatch events.
+ * Returns a frozen DispatchTriggerConfig directly.
+ */
+import type { DispatchConfigInput, DispatchTriggerConfig } from './types.js';
+/**
+ * Create a repository dispatch trigger configuration.
+ *
+ * @example
+ * // Match any dispatch event
+ * dispatch()
+ *
+ * // Match specific event types
+ * dispatch({ types: ['deploy', 'rollback'] })
+ */
+export declare function dispatch(config?: DispatchConfigInput): DispatchTriggerConfig;
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/triggers/dispatch.js

@@ -0,0 +1,27 @@
+import "../chunk-gOLHoazu.js";
+import { asArray, toBranchPattern } from "./types.js";
+//#region src/triggers/dispatch.ts
+/**
+* Create a repository dispatch trigger configuration.
+*
+* @example
+* // Match any dispatch event
+* dispatch()
+*
+* // Match specific event types
+* dispatch({ types: ['deploy', 'rollback'] })
+*/
+function dispatch(config) {
+	const repos = config?.repos ? asArray(config.repos).map(toBranchPattern) : [];
+	const result = {
+		_tag: "DispatchTrigger",
+		types: Object.freeze(config?.types ? [...config.types] : []),
+		repos: Object.freeze([...repos]),
+		...config?.description !== void 0 && { description: config.description }
+	};
+	return Object.freeze(result);
+}
+//#endregion
+export { dispatch };
+
+//# sourceMappingURL=dispatch.js.map

package/dist/triggers/fork.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Fork trigger helper - creates triggers for fork events.
+ * Returns a frozen ForkTriggerConfig directly.
+ */
+import type { ForkConfigInput, ForkTriggerConfig } from './types.js';
+/**
+ * Create a fork trigger configuration. No filter fields.
+ *
+ * @example
+ * // Match any fork event
+ * fork()
+ *
+ * // With description
+ * fork({ description: 'Track repository forks' })
+ */
+export declare function fork(config?: ForkConfigInput): ForkTriggerConfig;
+//# sourceMappingURL=fork.d.ts.map

package/dist/triggers/fork.js

@@ -0,0 +1,26 @@
+import "../chunk-gOLHoazu.js";
+import { asArray, toBranchPattern } from "./types.js";
+//#region src/triggers/fork.ts
+/**
+* Create a fork trigger configuration. No filter fields.
+*
+* @example
+* // Match any fork event
+* fork()
+*
+* // With description
+* fork({ description: 'Track repository forks' })
+*/
+function fork(config) {
+	const repos = config?.repos ? asArray(config.repos).map(toBranchPattern) : [];
+	const result = {
+		_tag: "ForkTrigger",
+		repos: Object.freeze([...repos]),
+		...config?.description !== void 0 && { description: config.description }
+	};
+	return Object.freeze(result);
+}
+//#endregion
+export { fork };
+
+//# sourceMappingURL=fork.js.map

package/dist/triggers/generic-webhook.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Generic webhook trigger helper - creates triggers for non-GitHub webhook sources.
+ * Returns a frozen GenericWebhookTriggerConfig directly.
+ */
+import type { GenericWebhookConfigInput, GenericWebhookTriggerConfig } from './types.js';
+/**
+ * Create a generic webhook trigger configuration.
+ *
+ * @example
+ * // Match any event from a source
+ * genericWebhook({ source: 'my-service' })
+ *
+ * // Match specific event types
+ * genericWebhook({ source: 'my-service', events: ['deploy', 'rollback'] })
+ *
+ * // With JSONPath payload matching
+ * genericWebhook({ source: 'my-service', events: ['deploy'], match: { '$.env': 'prod' } })
+ *
+ * // With negative filter
+ * genericWebhook({ source: 'my-service', not: { '$.dry_run': true } })
+ *
+ * // With HMAC-SHA256 auth
+ * genericWebhook({ source: 'stripe', auth: { method: 'hmac-sha256', secret: 'stripe-key', signatureHeader: 'stripe-signature' } })
+ *
+ * // With API key auth
+ * genericWebhook({ source: 'slack', auth: { method: 'api-key', secret: 'slack-token' } })
+ *
+ * // With path pattern
+ * genericWebhook({ source: 'stripe', path: 'stripe/payments' })
+ */
+export declare function genericWebhook(config: GenericWebhookConfigInput): GenericWebhookTriggerConfig;
+//# sourceMappingURL=generic-webhook.d.ts.map

package/dist/triggers/generic-webhook.js

@@ -0,0 +1,45 @@
+import "../chunk-gOLHoazu.js";
+//#region src/triggers/generic-webhook.ts
+/**
+* Create a generic webhook trigger configuration.
+*
+* @example
+* // Match any event from a source
+* genericWebhook({ source: 'my-service' })
+*
+* // Match specific event types
+* genericWebhook({ source: 'my-service', events: ['deploy', 'rollback'] })
+*
+* // With JSONPath payload matching
+* genericWebhook({ source: 'my-service', events: ['deploy'], match: { '$.env': 'prod' } })
+*
+* // With negative filter
+* genericWebhook({ source: 'my-service', not: { '$.dry_run': true } })
+*
+* // With HMAC-SHA256 auth
+* genericWebhook({ source: 'stripe', auth: { method: 'hmac-sha256', secret: 'stripe-key', signatureHeader: 'stripe-signature' } })
+*
+* // With API key auth
+* genericWebhook({ source: 'slack', auth: { method: 'api-key', secret: 'slack-token' } })
+*
+* // With path pattern
+* genericWebhook({ source: 'stripe', path: 'stripe/payments' })
+*/
+function genericWebhook(config) {
+	if (!config.source || config.source.trim() === "") throw new Error("genericWebhook() requires a non-empty source");
+	const result = {
+		_tag: "GenericWebhookTrigger",
+		source: config.source,
+		...config.events !== void 0 && { events: Object.freeze([...config.events]) },
+		...config.match !== void 0 && { match: Object.freeze({ ...config.match }) },
+		...config.not !== void 0 && { not: Object.freeze({ ...config.not }) },
+		...config.auth !== void 0 && { auth: Object.freeze({ ...config.auth }) },
+		...config.path !== void 0 && { path: config.path },
+		...config.description !== void 0 && { description: config.description }
+	};
+	return Object.freeze(result);
+}
+//#endregion
+export { genericWebhook };
+
+//# sourceMappingURL=generic-webhook.js.map

package/dist/triggers/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Trigger helpers for defining when workflows run.
+ */
+export { pr } from './pr.js';
+export { push } from './push.js';
+export { tag } from './tag.js';
+export { comment } from './comment.js';
+export { review } from './review.js';
+export { reviewComment } from './review-comment.js';
+export { release } from './release.js';
+export { dispatch } from './dispatch.js';
+export { create } from './create.js';
+export { del as delete } from './delete.js';
+export { status } from './status.js';
+export { workflowRun } from './workflow-run.js';
+export { fork } from './fork.js';
+export { star } from './star.js';
+export { watch } from './watch.js';
+export { webhook } from './webhook.js';
+export { kiciEvent } from './kici-event.js';
+export { workflowComplete } from './workflow-complete.js';
+export { jobComplete } from './job-complete.js';
+export { genericWebhook } from './generic-webhook.js';
+export { schedule } from './schedule.js';
+export { lifecycle } from './lifecycle.js';
+export type { BranchPattern, BodyMatchPattern, PrEvent, PushEvent, PrTriggerConfig, PushTriggerConfig, TagTriggerConfig, CommentTriggerConfig, ReviewTriggerConfig, ReviewCommentTriggerConfig, ReleaseTriggerConfig, DispatchTriggerConfig, CreateTriggerConfig, DeleteTriggerConfig, StatusTriggerConfig, WorkflowRunTriggerConfig, ForkTriggerConfig, StarTriggerConfig, WatchTriggerConfig, WebhookTriggerConfig, TriggerConfig, PrConfigInput, PushConfigInput, TagConfigInput, CommentConfigInput, CommentAction, CommentSource, ReviewConfigInput, ReviewAction, ReviewState, ReviewCommentConfigInput, ReviewCommentAction, ReleaseConfigInput, ReleaseAction, DispatchConfigInput, CreateConfigInput, DeleteConfigInput, RefType, StatusConfigInput, StatusState, WorkflowRunConfigInput, WorkflowRunAction, ForkConfigInput, StarConfigInput, StarAction, WatchConfigInput, WatchAction, WebhookConfigInput, KiciEventConfigInput, KiciEventTriggerConfig, WorkflowCompleteConfigInput, WorkflowCompleteTriggerConfig, WorkflowCompleteStatus, JobCompleteConfigInput, JobCompleteTriggerConfig, JobCompleteStatus, GenericWebhookConfigInput, GenericWebhookTriggerConfig, GenericWebhookAuthMethod, GenericWebhookHmacAuth, GenericWebhookApiKeyAuth, GenericWebhookAuth, ScheduleConfigInput, ScheduleTriggerConfig, LifecycleEvent, LifecycleConfigInput, LifecycleTriggerConfig, } from './types.js';
+export { DEFAULT_PR_EVENTS, toBranchPattern } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/triggers/index.js

@@ -0,0 +1,25 @@
+import "../chunk-gOLHoazu.js";
+import { DEFAULT_PR_EVENTS, toBranchPattern } from "./types.js";
+import { pr } from "./pr.js";
+import { push } from "./push.js";
+import { tag } from "./tag.js";
+import { comment } from "./comment.js";
+import { review } from "./review.js";
+import { reviewComment } from "./review-comment.js";
+import { release } from "./release.js";
+import { dispatch } from "./dispatch.js";
+import { create } from "./create.js";
+import { del } from "./delete.js";
+import { status } from "./status.js";
+import { workflowRun } from "./workflow-run.js";
+import { fork } from "./fork.js";
+import { star } from "./star.js";
+import { watch } from "./watch.js";
+import { webhook } from "./webhook.js";
+import { kiciEvent } from "./kici-event.js";
+import { workflowComplete } from "./workflow-complete.js";
+import { jobComplete } from "./job-complete.js";
+import { genericWebhook } from "./generic-webhook.js";
+import { schedule } from "./schedule.js";
+import { lifecycle } from "./lifecycle.js";
+export { DEFAULT_PR_EVENTS, comment, create, del as delete, dispatch, fork, genericWebhook, jobComplete, kiciEvent, lifecycle, pr, push, release, review, reviewComment, schedule, star, status, tag, toBranchPattern, watch, webhook, workflowComplete, workflowRun };