@qoder-ai/qmind-cli 2.0.0 → 3.1.0

package/dist/bot-gateway-Hzjl50zu.js

@@ -0,0 +1,373 @@
+import { Y as timestampSchema, a as invalidArgument, c as optionalRecord, d as pagination, h as requiredText, l as optionalString, m as requiredString, n as call, p as queryPath, r as compactUndefined, s as optionalBoolean, t as assertNonEmptyPatch, u as optionalTrimmedString } from "./shared-BkQJzIZF.js";
+import { z } from "zod";
+//#region ../sdk/src/operations/bot-gateway-codecs.ts
+const botTimestamp = z.preprocess((value) => typeof value === "object" && value !== null && !Array.isArray(value) && !("seconds" in value) ? {
+	...value,
+	seconds: 0
+} : value, timestampSchema).optional();
+const jsonObject = z.record(z.string(), z.json());
+const fields = {
+	id: z.string().min(1),
+	org_id: z.string().default(""),
+	platform: z.string().default(""),
+	is_active: z.boolean().default(false),
+	created_at: botTimestamp,
+	updated_at: botTimestamp
+};
+function base(value) {
+	return {
+		id: value.id,
+		orgId: value.org_id,
+		platform: value.platform,
+		isActive: value.is_active,
+		...value.created_at === void 0 ? {} : { createdAt: value.created_at },
+		...value.updated_at === void 0 ? {} : { updatedAt: value.updated_at }
+	};
+}
+const platformAppSchema = z.object({
+	...fields,
+	app_name: z.string().default(""),
+	client_id: z.string().default("")
+}).transform((value) => ({
+	...base(value),
+	appName: value.app_name,
+	clientId: value.client_id
+}));
+const expertBindingSchema = z.object({
+	...fields,
+	user_id: z.string().default(""),
+	platform_app_id: z.string().default(""),
+	external_union_id: z.string().default(""),
+	external_nickname: z.string().default("")
+}).transform((value) => ({
+	...base(value),
+	userId: value.user_id,
+	platformAppId: value.platform_app_id,
+	externalUnionId: value.external_union_id,
+	externalNickname: value.external_nickname
+}));
+const groupBindingSchema = z.object({
+	...fields,
+	platform_app_id: z.string().default(""),
+	conversation_id: z.string().default(""),
+	conversation_name: z.string().default(""),
+	notebook_id: z.string().default(""),
+	context_window: z.int32().default(0),
+	writer_user_id: z.string().default(""),
+	instructions: jsonObject.nullish()
+}).transform((value) => ({
+	...base(value),
+	platformAppId: value.platform_app_id,
+	conversationId: value.conversation_id,
+	conversationName: value.conversation_name,
+	notebookId: value.notebook_id,
+	contextWindow: value.context_window,
+	writerUserId: value.writer_user_id,
+	...value.instructions == null ? {} : { instructions: value.instructions }
+}));
+const pageInfoSchema = z.object({
+	current_page: z.int32().nonnegative().default(0),
+	last_page: z.int32().nonnegative().default(0),
+	next_page: z.int32().nonnegative().default(0),
+	prev_page: z.int32().nonnegative().default(0),
+	page_size: z.int32().nonnegative().default(0),
+	total_size: z.int32().nonnegative().default(0),
+	next_token: z.string().default("")
+}).transform((value) => ({
+	currentPage: value.current_page,
+	lastPage: value.last_page,
+	nextPage: value.next_page,
+	previousPage: value.prev_page,
+	pageSize: value.page_size,
+	totalSize: value.total_size,
+	nextToken: value.next_token
+}));
+const platformAppListSchema = z.object({
+	apps: z.array(platformAppSchema).nullish(),
+	pages: pageInfoSchema.nullish()
+}).transform((value) => ({
+	apps: value.apps ?? [],
+	...value.pages == null ? {} : { pages: value.pages }
+}));
+const expertBindingListSchema = z.object({
+	bindings: z.array(expertBindingSchema).nullish(),
+	pages: pageInfoSchema.nullish()
+}).transform((value) => ({
+	bindings: value.bindings ?? [],
+	...value.pages == null ? {} : { pages: value.pages }
+}));
+const groupBindingListSchema = z.object({
+	bindings: z.array(groupBindingSchema).nullish(),
+	pages: pageInfoSchema.nullish()
+}).transform((value) => ({
+	bindings: value.bindings ?? [],
+	...value.pages == null ? {} : { pages: value.pages }
+}));
+const publishDingTalkSchema = z.object({
+	binding_code: z.string().min(1),
+	bind_command: z.string().min(1),
+	group_binding: groupBindingSchema
+}).transform((value) => ({
+	bindingCode: value.binding_code,
+	bindCommand: value.bind_command,
+	groupBinding: value.group_binding
+}));
+const inviteDingTalkSchema = z.object({
+	binding_code: z.string().min(1),
+	bind_command: z.string().min(1),
+	expert_binding: expertBindingSchema
+}).transform((value) => ({
+	bindingCode: value.binding_code,
+	bindCommand: value.bind_command,
+	expertBinding: value.expert_binding
+}));
+const botDeleteSchema = z.object({}).transform(() => void 0);
+function optionalInt32(value, field) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isInteger(value) || value < -2147483648 || value > 2147483647) throw invalidArgument(`${field} must be an int32`, field);
+	return value;
+}
+function isJson(value, ancestors) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (typeof value !== "object" || ancestors.has(value)) return false;
+	if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return false;
+	if (Object.getOwnPropertySymbols(value).length > 0) return false;
+	ancestors.add(value);
+	const valid = (Array.isArray(value) ? Array.from(value) : Object.values(value)).every((child) => isJson(child, ancestors));
+	ancestors.delete(value);
+	return valid;
+}
+function optionalInstructions(value) {
+	const object = optionalRecord(value, "instructions");
+	if (object === void 0) return void 0;
+	try {
+		if (isJson(object, /* @__PURE__ */ new Set())) return object;
+	} catch {}
+	throw invalidArgument("instructions must contain only JSON values", "instructions");
+}
+//#endregion
+//#region ../sdk/src/operations/bot-gateway.ts
+function groupFields(input) {
+	return compactUndefined({
+		conversation_name: optionalString(input?.conversationName, "conversationName"),
+		context_window: optionalInt32(input?.contextWindow, "contextWindow"),
+		writer_user_id: optionalString(input?.writerUserId, "writerUserId"),
+		is_active: optionalBoolean(input?.isActive, "isActive"),
+		instructions: optionalInstructions(input?.instructions)
+	});
+}
+function patch(body) {
+	assertNonEmptyPatch(body, "input");
+	return body;
+}
+function createBotGatewayOperations(context) {
+	const path = (notebookId, ...segments) => context.profile.apiPath("notebooks", requiredString(notebookId, "notebookId"), "botgw", ...segments);
+	const listPath = (notebookId, resource, input = {}) => {
+		const page = pagination({
+			page: input.page ?? 1,
+			pageSize: input.pageSize ?? 20
+		});
+		const onlyActive = optionalBoolean(input.onlyActive, "onlyActive");
+		return queryPath(path(notebookId, resource), [
+			["page", optionalInt32(page.page, "page")],
+			["page_size", optionalInt32(page.pageSize, "pageSize")],
+			["platform", optionalTrimmedString(input.platform, "platform")],
+			["only_active", onlyActive === void 0 ? void 0 : String(onlyActive)],
+			["platform_app_id", resource === "platform-apps" ? void 0 : optionalTrimmedString(input.platformAppId, "platformAppId")],
+			["user_id", resource === "expert-bindings" ? optionalTrimmedString(input.userId, "userId") : void 0]
+		]);
+	};
+	return {
+		async listPlatformApps(notebookId, input, options) {
+			return call(context, {
+				callOptions: options,
+				capability: "botGateway",
+				method: "GET",
+				idempotent: true,
+				operation: "botGateway.platformApps.list",
+				path: listPath(notebookId, "platform-apps", input),
+				schema: platformAppListSchema
+			});
+		},
+		async createPlatformApp(notebookId, input, options) {
+			const body = compactUndefined({
+				platform: requiredString(input?.platform, "platform"),
+				app_name: requiredString(input?.appName, "appName"),
+				client_id: requiredString(input?.clientId, "clientId"),
+				client_secret: requiredText(input?.clientSecret, "clientSecret"),
+				is_active: optionalBoolean(input?.isActive, "isActive")
+			});
+			return call(context, {
+				body,
+				callOptions: options,
+				capability: "botGateway",
+				method: "POST",
+				idempotent: false,
+				operation: "botGateway.platformApps.create",
+				path: path(notebookId, "platform-apps"),
+				schema: platformAppSchema
+			});
+		},
+		async updatePlatformApp(notebookId, appId, input, options) {
+			const body = patch(compactUndefined({
+				app_name: optionalString(input?.appName, "appName"),
+				client_secret: optionalString(input?.clientSecret, "clientSecret"),
+				is_active: optionalBoolean(input?.isActive, "isActive")
+			}));
+			return call(context, {
+				body,
+				callOptions: options,
+				capability: "botGateway",
+				method: "PATCH",
+				idempotent: false,
+				operation: "botGateway.platformApps.update",
+				path: path(notebookId, "platform-apps", requiredString(appId, "appId")),
+				schema: platformAppSchema
+			});
+		},
+		async deletePlatformApp(notebookId, appId, options) {
+			return call(context, {
+				callOptions: options,
+				capability: "botGateway",
+				method: "DELETE",
+				idempotent: false,
+				operation: "botGateway.platformApps.delete",
+				path: path(notebookId, "platform-apps", requiredString(appId, "appId")),
+				schema: botDeleteSchema
+			});
+		},
+		async listExpertBindings(notebookId, input, options) {
+			return call(context, {
+				callOptions: options,
+				capability: "botGateway",
+				method: "GET",
+				idempotent: true,
+				operation: "botGateway.expertBindings.list",
+				path: listPath(notebookId, "expert-bindings", input),
+				schema: expertBindingListSchema
+			});
+		},
+		async updateExpertBinding(notebookId, bindingId, input, options) {
+			const body = patch(compactUndefined({
+				external_nickname: optionalString(input?.externalNickname, "externalNickname"),
+				is_active: optionalBoolean(input?.isActive, "isActive")
+			}));
+			return call(context, {
+				body,
+				callOptions: options,
+				capability: "botGateway",
+				method: "PATCH",
+				idempotent: false,
+				operation: "botGateway.expertBindings.update",
+				path: path(notebookId, "expert-bindings", requiredString(bindingId, "bindingId")),
+				schema: expertBindingSchema
+			});
+		},
+		async deleteExpertBinding(notebookId, bindingId, options) {
+			return call(context, {
+				callOptions: options,
+				capability: "botGateway",
+				method: "DELETE",
+				idempotent: false,
+				operation: "botGateway.expertBindings.delete",
+				path: path(notebookId, "expert-bindings", requiredString(bindingId, "bindingId")),
+				schema: botDeleteSchema
+			});
+		},
+		async listGroupBindings(notebookId, input, options) {
+			return call(context, {
+				callOptions: options,
+				capability: "botGateway",
+				method: "GET",
+				idempotent: true,
+				operation: "botGateway.groupBindings.list",
+				path: listPath(notebookId, "group-bindings", input),
+				schema: groupBindingListSchema
+			});
+		},
+		async createGroupBinding(notebookId, input, options) {
+			const body = {
+				...groupFields(input),
+				platform_app_id: requiredString(input?.platformAppId, "platformAppId"),
+				conversation_id: requiredString(input?.conversationId, "conversationId")
+			};
+			return call(context, {
+				body,
+				callOptions: options,
+				capability: "botGateway",
+				method: "POST",
+				idempotent: false,
+				operation: "botGateway.groupBindings.create",
+				path: path(notebookId, "group-bindings"),
+				schema: groupBindingSchema
+			});
+		},
+		async updateGroupBinding(notebookId, bindingId, input, options) {
+			const body = patch(compactUndefined({
+				...groupFields(input),
+				notebook_id: optionalString(input?.notebookId, "notebookId")
+			}));
+			return call(context, {
+				body,
+				callOptions: options,
+				capability: "botGateway",
+				method: "PATCH",
+				idempotent: false,
+				operation: "botGateway.groupBindings.update",
+				path: path(notebookId, "group-bindings", requiredString(bindingId, "bindingId")),
+				schema: groupBindingSchema
+			});
+		},
+		async deleteGroupBinding(notebookId, bindingId, options) {
+			return call(context, {
+				callOptions: options,
+				capability: "botGateway",
+				method: "DELETE",
+				idempotent: false,
+				operation: "botGateway.groupBindings.delete",
+				path: path(notebookId, "group-bindings", requiredString(bindingId, "bindingId")),
+				schema: botDeleteSchema
+			});
+		},
+		async publishDingTalk(notebookId, input, options) {
+			const body = compactUndefined({
+				platform_app_id: requiredString(input?.platformAppId, "platformAppId"),
+				context_window: optionalInt32(input?.contextWindow, "contextWindow"),
+				instructions: optionalInstructions(input?.instructions)
+			});
+			return call(context, {
+				body,
+				callOptions: options,
+				capability: "botGateway",
+				method: "POST",
+				idempotent: false,
+				operation: "botGateway.dingTalk.publish",
+				path: path(notebookId, "dingtalk", "publish"),
+				schema: publishDingTalkSchema
+			});
+		},
+		async inviteDingTalkExpert(notebookId, input, options) {
+			const userId = optionalTrimmedString(input?.userId, "userId");
+			const email = optionalTrimmedString(input?.email, "email");
+			if (userId === void 0 && email === void 0) throw invalidArgument("provide userId or email", "input");
+			const body = compactUndefined({
+				platform_app_id: requiredString(input?.platformAppId, "platformAppId"),
+				user_id: userId,
+				email
+			});
+			return call(context, {
+				body,
+				callOptions: options,
+				capability: "botGateway",
+				method: "POST",
+				idempotent: false,
+				operation: "botGateway.dingTalk.inviteExpert",
+				path: path(notebookId, "dingtalk", "experts", "invite"),
+				schema: inviteDingTalkSchema
+			});
+		}
+	};
+}
+//#endregion
+export { createBotGatewayOperations };

package/dist/cards-DsMbd-g1.js

@@ -0,0 +1,132 @@
+import { S as cardSchema, a as invalidArgument, c as optionalRecord, d as pagination, g as stringList, h as requiredText, l as optionalString, m as requiredString, n as call, p as queryPath, r as compactUndefined, u as optionalTrimmedString, x as cardListSchema, y as batchMutationResultSchema } from "./shared-BkQJzIZF.js";
+import { z } from "zod";
+//#region ../sdk/src/operations/compilation-results.ts
+function linksBody(value, field) {
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value)) throw invalidArgument(`${field} must be an array`, field);
+	return value.map((value, index) => {
+		const name = `${field}[${index}]`;
+		const link = optionalRecord(value, name);
+		const targetId = optionalTrimmedString(link?.targetId, `${name}.targetId`);
+		const targetRef = optionalTrimmedString(link?.targetRef, `${name}.targetRef`);
+		if (targetId === void 0 && targetRef === void 0) throw invalidArgument(`${name} requires targetId or targetRef`, name);
+		return compactUndefined({
+			description: optionalString(link?.description, `${name}.description`),
+			linkType: optionalTrimmedString(link?.linkType, `${name}.linkType`),
+			targetId,
+			targetRef
+		});
+	});
+}
+function compilationResultBody(value) {
+	if (!Array.isArray(value) || value.length === 0) throw invalidArgument("cards must be a non-empty array", "cards");
+	return { cards: value.map((value, index) => {
+		const name = `cards[${index}]`;
+		const card = optionalRecord(value, name);
+		return compactUndefined({
+			cardType: optionalTrimmedString(card?.cardType, `${name}.cardType`),
+			content: requiredText(card?.content, `${name}.content`),
+			id: optionalTrimmedString(card?.id, `${name}.id`),
+			keywords: card?.keywords === void 0 ? void 0 : stringList(card.keywords, `${name}.keywords`),
+			links: linksBody(card?.links, `${name}.links`),
+			refId: optionalTrimmedString(card?.refId, `${name}.refId`),
+			title: requiredString(card?.title, `${name}.title`)
+		});
+	}) };
+}
+const saveCompilationResultSchema = z.object({
+	cards: z.array(z.object({
+		id: z.string().min(1),
+		refId: z.string().optional()
+	})).nullish().transform((cards) => cards ?? []),
+	failureCount: z.number().int().nonnegative(),
+	successCount: z.number().int().nonnegative()
+});
+//#endregion
+//#region ../sdk/src/operations/cards.ts
+function createCardOperations(context) {
+	const listCards = async (notebookId, input = {}, options, featured = false) => {
+		const notebook = requiredString(notebookId, "notebookId");
+		const normalizedPage = pagination({
+			page: input.page ?? 1,
+			pageSize: input.pageSize ?? 20
+		});
+		const category = optionalTrimmedString(input.category, "category");
+		const query = optionalTrimmedString(input.query, "query");
+		const root = context.profile.apiPath(featured ? "featured-notebooks" : "notebooks", notebook, "cards");
+		const path = queryPath(root, [
+			["category", category],
+			["query", query],
+			["page", normalizedPage.page],
+			["page_size", normalizedPage.pageSize]
+		]);
+		return call(context, {
+			callOptions: options,
+			capability: featured ? "featuredNotebooks.read" : "cards.read",
+			idempotent: true,
+			method: "GET",
+			operation: featured ? "featuredCards.list" : "cards.list",
+			path,
+			schema: cardListSchema
+		});
+	};
+	return {
+		async saveCompilationResult(notebookId, input, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			return call(context, {
+				body: compilationResultBody(input?.cards),
+				callOptions: options,
+				capability: "cards.saveResults",
+				idempotent: false,
+				method: "POST",
+				operation: "cards.saveCompilationResult",
+				path: context.profile.apiPath("notebooks", notebook, "cards", "save-compilation-result"),
+				schema: saveCompilationResultSchema
+			});
+		},
+		async batchDeleteCards(notebookId, cardIds, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const ids = stringList(cardIds, "cardIds", { min: 1 });
+			return call(context, {
+				body: { cardIds: ids },
+				callOptions: options,
+				capability: "cards.write",
+				idempotent: false,
+				method: "POST",
+				operation: "cards.batchDelete",
+				path: context.profile.apiPath("notebooks", notebook, "cards", "batch-delete"),
+				schema: batchMutationResultSchema
+			});
+		},
+		async deleteCard(notebookId, cardId, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const card = requiredString(cardId, "cardId");
+			return call(context, {
+				callOptions: options,
+				capability: "cards.write",
+				idempotent: false,
+				method: "DELETE",
+				operation: "cards.delete",
+				path: context.profile.apiPath("notebooks", notebook, "cards", card),
+				schema: batchMutationResultSchema
+			});
+		},
+		async getCard(notebookId, cardId, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const card = requiredString(cardId, "cardId");
+			return call(context, {
+				callOptions: options,
+				capability: "cards.read",
+				idempotent: true,
+				method: "GET",
+				operation: "cards.get",
+				path: context.profile.apiPath("notebooks", notebook, "cards", card),
+				schema: cardSchema
+			});
+		},
+		listCards: (notebookId, input, options) => listCards(notebookId, input, options),
+		listFeaturedCards: (notebookId, input, options) => listCards(notebookId, input, options, true)
+	};
+}
+//#endregion
+export { createCardOperations };

package/dist/imports-B01ERZgD.js

@@ -0,0 +1,126 @@
+import { O as importProvidersSchema, _ as aliDingImportRunItemListSchema, a as invalidArgument, d as pagination, et as assertCapability, m as requiredString, n as call, p as queryPath, v as aliDingImportRunSchema } from "./shared-BkQJzIZF.js";
+//#region ../sdk/src/operations/imports.ts
+const aliDingHost = "alidocs.dingtalk.com";
+const requestIdPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
+/**
+* A canonical AliDing URL identifies exactly one node or knowledge base. Share links, short links,
+* query strings and fragments are aliases, so they are rejected rather than silently trimmed.
+*/
+function canonicalAliDingUrl(value, scope) {
+	const raw = requiredString(value, "url");
+	let url;
+	try {
+		url = new URL(raw);
+	} catch (cause) {
+		throw invalidArgument("url must be a canonical AliDing HTTPS URL", "url", { cause });
+	}
+	if (url.origin !== `https://${aliDingHost}`) throw invalidArgument(`url must be an https://${aliDingHost} address`, "url");
+	if (url.search.length > 0 || url.hash.length > 0 || url.username.length > 0 || url.password.length > 0) throw invalidArgument("url must not carry a query, fragment or credentials", "url");
+	const prefix = scope === "nodeSubtree" ? "/i/nodes/" : "/i/spaces/";
+	if (!url.pathname.startsWith(prefix) || url.pathname === prefix) throw invalidArgument(`url must be an AliDing ${prefix} address for this import scope`, "url");
+	return url.toString();
+}
+function importRunBody(input, scope) {
+	const requestId = requiredString(input?.requestId, "requestId");
+	if (!requestIdPattern.test(requestId.toLowerCase())) throw invalidArgument("requestId must be a UUID", "requestId");
+	return {
+		requestId,
+		url: canonicalAliDingUrl(input?.url, scope)
+	};
+}
+function createImportOperations(context) {
+	return {
+		async getAliDingImportRun(notebookId, runId, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const run = requiredString(runId, "runId");
+			assertCapability(context.profile, "imports.aliDing", "imports.aliDing.getRun");
+			return call(context, {
+				callOptions: options,
+				capability: "imports.aliDing",
+				idempotent: true,
+				method: "GET",
+				operation: "imports.aliDing.getRun",
+				path: context.profile.mindPath("notebooks", notebook, "aliding", "import-runs", run),
+				schema: aliDingImportRunSchema
+			});
+		},
+		async listAliDingImportRunItems(notebookId, runId, input = {}, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const run = requiredString(runId, "runId");
+			const normalizedPage = pagination(input);
+			assertCapability(context.profile, "imports.aliDing", "imports.aliDing.listRunItems");
+			const base = context.profile.mindPath("notebooks", notebook, "aliding", "import-runs", run, "items");
+			return call(context, {
+				callOptions: options,
+				capability: "imports.aliDing",
+				idempotent: true,
+				method: "GET",
+				operation: "imports.aliDing.listRunItems",
+				path: queryPath(base, [
+					["pagination.currentPage", normalizedPage.page],
+					["pagination.pageSize", normalizedPage.pageSize],
+					["status", wireItemStatus(input.status)],
+					["contentStatus", wireContentStatus(input.contentStatus)],
+					["descendantsStatus", wireDescendantsStatus(input.descendantsStatus)]
+				]),
+				schema: aliDingImportRunItemListSchema
+			});
+		},
+		async listImportProviders(options) {
+			assertCapability(context.profile, "imports.discover", "imports.discover");
+			return call(context, {
+				callOptions: options,
+				capability: "imports.discover",
+				idempotent: true,
+				method: "GET",
+				operation: "imports.discover",
+				path: context.profile.mindPath("import-sources"),
+				schema: importProvidersSchema
+			});
+		},
+		async startAliDingKnowledgeBaseImport(notebookId, input, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const body = importRunBody(input, "knowledgeBase");
+			assertCapability(context.profile, "imports.aliDing", "imports.aliDing.createKnowledgeBaseRun");
+			return call(context, {
+				body,
+				callOptions: options,
+				capability: "imports.aliDing",
+				idempotent: false,
+				method: "POST",
+				operation: "imports.aliDing.createKnowledgeBaseRun",
+				path: context.profile.mindPath("notebooks", notebook, "aliding", "knowledge-base-import-runs"),
+				schema: aliDingImportRunSchema
+			});
+		},
+		async startAliDingNodeSubtreeImport(notebookId, input, options) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const body = importRunBody(input, "nodeSubtree");
+			assertCapability(context.profile, "imports.aliDing", "imports.aliDing.createNodeSubtreeRun");
+			return call(context, {
+				body,
+				callOptions: options,
+				capability: "imports.aliDing",
+				idempotent: false,
+				method: "POST",
+				operation: "imports.aliDing.createNodeSubtreeRun",
+				path: context.profile.mindPath("notebooks", notebook, "aliding", "node-subtree-import-runs"),
+				schema: aliDingImportRunSchema
+			});
+		}
+	};
+}
+function wireItemStatus(value) {
+	return value === void 0 ? void 0 : `ALI_DING_IMPORT_ITEM_STATUS_${screamingCase(value)}`;
+}
+function wireContentStatus(value) {
+	return value === void 0 ? void 0 : `ALI_DING_IMPORT_CONTENT_STATUS_${screamingCase(value)}`;
+}
+function wireDescendantsStatus(value) {
+	return value === void 0 ? void 0 : `ALI_DING_IMPORT_DESCENDANTS_STATUS_${screamingCase(value)}`;
+}
+function screamingCase(value) {
+	return value.replace(/([a-z0-9])([A-Z])/gu, "$1_$2").toUpperCase();
+}
+//#endregion
+export { createImportOperations };