@copado/agentia-cli 0.1.0-alpha.1

package/dist/cli/openapi-command.js

@@ -0,0 +1,718 @@
+import { findCredentialAuthUrlOperation, findCredentialCreateOperation, findCredentialGetOperation, findEnvironmentCreateOperation, findEnvironmentGetOperation, findEnvironmentListOperation, findMetadataIndexRefreshOperation, findMetadataIndexRefreshStatusOperation, findMetadataIndexSearchOperation, findDeploySelectionOperation, findCommitOperation, findRepositoryCreateOperation, findRepositoryGetOperation, findRepositoryListOperation, findRepositorySshKeyOperation, findRepositoryHttpCredentialsOperation, findRepositoryValidateOperation, findPipelineListOperation, findPipelineGetOperation, findPipelineCreateOperation, findPipelineUpdateOperation, findPipelineDeleteOperation, findPipelineConnectionListOperation, findPipelineConnectionGetOperation, findPipelineConnectionCreateOperation, findPipelineConnectionUpdateOperation, findPipelineConnectionDeleteOperation, findWorkItemListOperation, findWorkItemGetOperation, findWorkItemCreateOperation, findWorkItemUpdateOperation, findWorkItemDeleteOperation, findOperationByCommandTag, findUserStoryCreateOperation, loadOpenApiFromPath, resolveBundledOpenApiPath, resolveBundledOpenApiV2Path, } from "../openapi.js";
+import { buildBodyFromOperation } from "./body-builder.js";
+import { createCicdV2EnvironmentsCredentialsApi, createCicdV2MetadataApi, createCicdV2ActionsApi, createCicdV2RepositoriesApi, createCicdV2PipelinesApi, createCicdV2PipelineConnectionsApi, createCicdV2PlanWorkItemsApi, gatewayHeaderParams, } from "../transport/cicd-client-factory.js";
+import { invokeGenerated } from "../transport/invoke-generated.js";
+import { buildRefreshMetadataIndexRequest, buildMetadataIndexSearchRequest, fetchMetadataIndexRefreshStatus, pollMetadataIndexRefreshStatus, resolveModuleType, } from "../cicd/metadata-index.js";
+import { buildDeploySelectionRequest, } from "../cicd/deploy-selection.js";
+import { buildCommitRequest, } from "../cicd/commit-request.js";
+import { buildPipelineCreateRequest, buildPipelineUpdateRequest, } from "../cicd/pipeline-request.js";
+import { buildPipelineConnectionCreateRequest, buildPipelineConnectionUpdateRequest, } from "../cicd/pipeline-connection-request.js";
+import { buildWorkItemCreateRequest, buildWorkItemUpdateRequest, } from "../cicd/work-item-request.js";
+import { callCicdGateway } from "../cicd-client.js";
+import { handleCicdFailure, writeCicdSuccess } from "../cicd-client.js";
+const COMMAND_DISCOVERERS = {
+    "environment-list": findEnvironmentListOperation,
+    "environment-get": findEnvironmentGetOperation,
+    "environment-create": findEnvironmentCreateOperation,
+    "credential-get": findCredentialGetOperation,
+    "credential-create": findCredentialCreateOperation,
+    "credential-authenticate": findCredentialAuthUrlOperation,
+    "user-story-create": findUserStoryCreateOperation,
+    "metadata-index-refresh": findMetadataIndexRefreshOperation,
+    "metadata-index-refresh-status": findMetadataIndexRefreshStatusOperation,
+    "metadata-index-search": findMetadataIndexSearchOperation,
+    "deploy-selection": findDeploySelectionOperation,
+    commit: findCommitOperation,
+    "repository-list": findRepositoryListOperation,
+    "repository-get": findRepositoryGetOperation,
+    "repository-create": findRepositoryCreateOperation,
+    "repository-ssh-key": findRepositorySshKeyOperation,
+    "repository-http-credentials": findRepositoryHttpCredentialsOperation,
+    "repository-validate": findRepositoryValidateOperation,
+    "pipeline-list": findPipelineListOperation,
+    "pipeline-get": findPipelineGetOperation,
+    "pipeline-create": findPipelineCreateOperation,
+    "pipeline-update": findPipelineUpdateOperation,
+    "pipeline-delete": findPipelineDeleteOperation,
+    "pipeline-connection-list": findPipelineConnectionListOperation,
+    "pipeline-connection-get": findPipelineConnectionGetOperation,
+    "pipeline-connection-create": findPipelineConnectionCreateOperation,
+    "pipeline-connection-update": findPipelineConnectionUpdateOperation,
+    "pipeline-connection-delete": findPipelineConnectionDeleteOperation,
+    "work-item-list": findWorkItemListOperation,
+    "work-item-get": findWorkItemGetOperation,
+    "work-item-create": findWorkItemCreateOperation,
+    "work-item-update": findWorkItemUpdateOperation,
+    "work-item-delete": findWorkItemDeleteOperation,
+};
+export function resolveBundledOpenApiPathForVersion(version) {
+    return version === "v2"
+        ? resolveBundledOpenApiV2Path()
+        : resolveBundledOpenApiPath();
+}
+export function discoverOperation(doc, commandTag) {
+    const tagged = findOperationByCommandTag(doc, commandTag);
+    if (tagged)
+        return tagged;
+    const discoverer = COMMAND_DISCOVERERS[commandTag];
+    return discoverer?.(doc) ?? null;
+}
+export function loadBundledOpenApi(version) {
+    return loadOpenApiFromPath(resolveBundledOpenApiPathForVersion(version));
+}
+export async function runGeneratedEnvironmentCreate(profile, opts, options) {
+    const doc = loadBundledOpenApi("v2");
+    const discovered = discoverOperation(doc, "environment-create");
+    if (!discovered) {
+        process.stderr.write('No "environment create" operation found in cicd_openapi.v2.json.\n');
+        process.exitCode = 1;
+        return;
+    }
+    const built = buildBodyFromOperation(doc, discovered.operation, opts);
+    if (!built.ok) {
+        process.stderr.write(`${built.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2EnvironmentsCredentialsApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.createEnvironmentCorpusEnvironmentsPostRaw({
+        ...headers,
+        environmentCreateRequest: built.body,
+    }));
+}
+export async function runGeneratedEnvironmentList(profile, options) {
+    const api = createCicdV2EnvironmentsCredentialsApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.listEnvironmentsCorpusEnvironmentsGetRaw(headers));
+}
+export async function runGeneratedEnvironmentGet(profile, environmentId, options) {
+    const id = environmentId.trim();
+    if (!id) {
+        process.stderr.write("Missing required argument: environment-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2EnvironmentsCredentialsApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.getEnvironmentCorpusEnvironmentsEnvironmentIdGetRaw({
+        ...headers,
+        environmentId: id,
+    }));
+}
+export async function runGeneratedRepositoryList(profile, options) {
+    const api = createCicdV2RepositoriesApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.listGitRepositoriesCorpusRepositoriesGetRaw(headers));
+}
+export async function runGeneratedRepositoryGet(profile, repositoryId, options) {
+    const id = repositoryId.trim();
+    if (!id) {
+        process.stderr.write("Missing required argument: repository-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2RepositoriesApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.getGitRepositoryCorpusRepositoriesRepositoryIdGetRaw({
+        ...headers,
+        repositoryId: id,
+    }));
+}
+export async function runGeneratedRepositorySshKey(profile, repositoryId, options) {
+    const id = repositoryId.trim();
+    if (!id) {
+        process.stderr.write("Missing required option: --repository-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2RepositoriesApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.generateGitRepositorySshKeyCorpusRepositoriesRepositoryIdSshkeyPostRaw({
+        ...headers,
+        repositoryId: id,
+    }));
+}
+export async function runGeneratedRepositoryValidate(profile, repositoryId, options) {
+    const id = repositoryId.trim();
+    if (!id) {
+        process.stderr.write("Missing required option: --repository-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2RepositoriesApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.validateRepositoryAuthenticationCorpusRepositoriesRepositoryIdValidatePostRaw({
+        ...headers,
+        repositoryId: id,
+    }));
+}
+export async function runGeneratedRepositoryHttpCredentials(profile, repositoryId, opts, options) {
+    const id = repositoryId.trim();
+    if (!id) {
+        process.stderr.write("Missing required option: --repository-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const doc = loadBundledOpenApi("v2");
+    const discovered = discoverOperation(doc, "repository-http-credentials");
+    if (!discovered) {
+        process.stderr.write('No "repository http-credentials" operation found in cicd_openapi.v2.json.\n');
+        process.exitCode = 1;
+        return;
+    }
+    const built = buildBodyFromOperation(doc, discovered.operation, opts);
+    if (!built.ok) {
+        process.stderr.write(`${built.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2RepositoriesApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.updateRepositoryHttpCredentialsCorpusRepositoriesRepositoryIdHttpcredentialsPutRaw({
+        ...headers,
+        repositoryId: id,
+        gitRepositoryHttpCredentialsRequest: built.body,
+    }));
+}
+export async function runGeneratedRepositoryCreate(profile, opts, options) {
+    const doc = loadBundledOpenApi("v2");
+    const discovered = discoverOperation(doc, "repository-create");
+    if (!discovered) {
+        process.stderr.write('No "repository create" operation found in cicd_openapi.v2.json.\n');
+        process.exitCode = 1;
+        return;
+    }
+    const built = buildBodyFromOperation(doc, discovered.operation, opts);
+    if (!built.ok) {
+        process.stderr.write(`${built.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2RepositoriesApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.createGitRepositoryCorpusRepositoriesPostRaw({
+        ...headers,
+        gitRepositoryCreateRequest: built.body,
+    }));
+}
+export async function runGeneratedPipelineList(profile, options) {
+    const api = createCicdV2PipelinesApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.listPipelinesCorpusPipelinesGetRaw(headers));
+}
+export async function runGeneratedPipelineGet(profile, pipelineId, options) {
+    const id = pipelineId.trim();
+    if (!id) {
+        process.stderr.write("Missing required argument: pipeline-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2PipelinesApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.getPipelineCorpusPipelinesPipelineIdGetRaw({
+        ...headers,
+        pipelineId: id,
+    }));
+}
+export async function runGeneratedPipelineCreate(profile, opts, options) {
+    const doc = loadBundledOpenApi("v2");
+    const discovered = discoverOperation(doc, "pipeline-create");
+    if (!discovered) {
+        process.stderr.write('No "pipeline create" operation found in cicd_openapi.v2.json.\n');
+        process.exitCode = 1;
+        return;
+    }
+    const built = buildPipelineCreateRequest(opts);
+    if (!built.ok) {
+        process.stderr.write(`${built.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2PipelinesApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.createPipelineCorpusPipelinesPostRaw({
+        ...headers,
+        pipelineCreateRequest: built.body,
+    }));
+}
+export async function runGeneratedPipelineUpdate(profile, pipelineId, opts, options) {
+    const id = pipelineId.trim();
+    if (!id) {
+        process.stderr.write("Missing required argument: pipeline-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const doc = loadBundledOpenApi("v2");
+    const discovered = discoverOperation(doc, "pipeline-update");
+    if (!discovered) {
+        process.stderr.write('No "pipeline update" operation found in cicd_openapi.v2.json.\n');
+        process.exitCode = 1;
+        return;
+    }
+    const built = buildPipelineUpdateRequest(opts);
+    if (!built.ok) {
+        process.stderr.write(`${built.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2PipelinesApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.updatePipelineCorpusPipelinesPipelineIdPatchRaw({
+        ...headers,
+        pipelineId: id,
+        pipelineUpdateRequest: built.body,
+    }));
+}
+export async function runGeneratedPipelineDelete(profile, pipelineId, options) {
+    const id = pipelineId.trim();
+    if (!id) {
+        process.stderr.write("Missing required argument: pipeline-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2PipelinesApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.deletePipelineCorpusPipelinesPipelineIdDeleteRaw({
+        ...headers,
+        pipelineId: id,
+    }));
+}
+export async function runGeneratedPipelineConnectionList(profile, pipelineId, options) {
+    const api = createCicdV2PipelineConnectionsApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    const filterPipelineId = pipelineId?.trim();
+    await invokeGenerated(() => api.listPipelineConnectionsCorpusPipelinesConnectionsGetRaw({
+        ...headers,
+        ...(filterPipelineId ? { pipelineId: filterPipelineId } : {}),
+    }));
+}
+export async function runGeneratedPipelineConnectionGet(profile, connectionId, options) {
+    const id = connectionId.trim();
+    if (!id) {
+        process.stderr.write("Missing required argument: connection-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2PipelineConnectionsApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.getPipelineConnectionCorpusPipelinesConnectionsConnectionIdGetRaw({
+        ...headers,
+        connectionId: id,
+    }));
+}
+export async function runGeneratedPipelineConnectionCreate(profile, opts, options) {
+    const doc = loadBundledOpenApi("v2");
+    const discovered = discoverOperation(doc, "pipeline-connection-create");
+    if (!discovered) {
+        process.stderr.write('No "pipeline connection create" operation found in cicd_openapi.v2.json.\n');
+        process.exitCode = 1;
+        return;
+    }
+    const built = buildPipelineConnectionCreateRequest(opts);
+    if (!built.ok) {
+        process.stderr.write(`${built.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2PipelineConnectionsApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.createPipelineConnectionCorpusPipelinesConnectionsPostRaw({
+        ...headers,
+        pipelineConnectionCreateRequest: built.body,
+    }));
+}
+export async function runGeneratedPipelineConnectionUpdate(profile, connectionId, opts, options) {
+    const id = connectionId.trim();
+    if (!id) {
+        process.stderr.write("Missing required argument: connection-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const doc = loadBundledOpenApi("v2");
+    const discovered = discoverOperation(doc, "pipeline-connection-update");
+    if (!discovered) {
+        process.stderr.write('No "pipeline connection update" operation found in cicd_openapi.v2.json.\n');
+        process.exitCode = 1;
+        return;
+    }
+    const built = buildPipelineConnectionUpdateRequest(opts);
+    if (!built.ok) {
+        process.stderr.write(`${built.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2PipelineConnectionsApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.updatePipelineConnectionCorpusPipelinesConnectionsConnectionIdPatchRaw({
+        ...headers,
+        connectionId: id,
+        pipelineConnectionUpdateRequest: built.body,
+    }));
+}
+export async function runGeneratedPipelineConnectionDelete(profile, connectionId, options) {
+    const id = connectionId.trim();
+    if (!id) {
+        process.stderr.write("Missing required argument: connection-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2PipelineConnectionsApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.deletePipelineConnectionCorpusPipelinesConnectionsConnectionIdDeleteRaw({
+        ...headers,
+        connectionId: id,
+    }));
+}
+export async function runGeneratedWorkItemList(profile, opts) {
+    const api = createCicdV2PlanWorkItemsApi(profile, opts);
+    const headers = gatewayHeaderParams(profile);
+    const filterPipelineId = opts?.pipelineId?.trim();
+    const filterReleaseId = opts?.releaseId?.trim();
+    await invokeGenerated(() => api.listWorkItemsPlanWorkItemsGetRaw({
+        ...headers,
+        ...(filterPipelineId ? { pipelineId: filterPipelineId } : {}),
+        ...(filterReleaseId ? { releaseId: filterReleaseId } : {}),
+    }));
+}
+export async function runGeneratedWorkItemGet(profile, workItemId, options) {
+    const id = workItemId.trim();
+    if (!id) {
+        process.stderr.write("Missing required argument: work-item-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2PlanWorkItemsApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.getWorkItemPlanWorkItemsWorkItemIdGetRaw({
+        ...headers,
+        workItemId: id,
+    }));
+}
+export async function runGeneratedWorkItemCreate(profile, opts, options) {
+    const doc = loadBundledOpenApi("v2");
+    const discovered = discoverOperation(doc, "work-item-create");
+    if (!discovered) {
+        process.stderr.write('No "work item create" operation found in cicd_openapi.v2.json.\n');
+        process.exitCode = 1;
+        return;
+    }
+    const built = buildWorkItemCreateRequest(opts);
+    if (!built.ok) {
+        process.stderr.write(`${built.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2PlanWorkItemsApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.createWorkItemPlanWorkItemsPostRaw({
+        ...headers,
+        workItemCreateRequest: built.body,
+    }));
+}
+export async function runGeneratedWorkItemUpdate(profile, workItemId, opts, options) {
+    const id = workItemId.trim();
+    if (!id) {
+        process.stderr.write("Missing required argument: work-item-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const doc = loadBundledOpenApi("v2");
+    const discovered = discoverOperation(doc, "work-item-update");
+    if (!discovered) {
+        process.stderr.write('No "work item update" operation found in cicd_openapi.v2.json.\n');
+        process.exitCode = 1;
+        return;
+    }
+    const built = buildWorkItemUpdateRequest(opts);
+    if (!built.ok) {
+        process.stderr.write(`${built.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2PlanWorkItemsApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.updateWorkItemPlanWorkItemsWorkItemIdPatchRaw({
+        ...headers,
+        workItemId: id,
+        workItemUpdateRequest: built.body,
+    }));
+}
+export async function runGeneratedWorkItemDelete(profile, workItemId, options) {
+    const id = workItemId.trim();
+    if (!id) {
+        process.stderr.write("Missing required argument: work-item-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2PlanWorkItemsApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.deleteWorkItemPlanWorkItemsWorkItemIdDeleteRaw({
+        ...headers,
+        workItemId: id,
+    }));
+}
+export async function runGeneratedCredentialCreate(profile, environmentId, opts, options) {
+    const doc = loadBundledOpenApi("v2");
+    const discovered = discoverOperation(doc, "credential-create");
+    if (!discovered) {
+        process.stderr.write('No "credential create" operation found in cicd_openapi.v2.json.\n');
+        process.exitCode = 1;
+        return;
+    }
+    const envId = environmentId.trim();
+    if (!envId) {
+        process.stderr.write("Missing required argument: environment-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const built = buildBodyFromOperation(doc, discovered.operation, opts);
+    if (!built.ok) {
+        process.stderr.write(`${built.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2EnvironmentsCredentialsApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.createEnvironmentCredentialCorpusEnvironmentsEnvironmentIdCredentialsPostRaw({
+        ...headers,
+        environmentId: envId,
+        credentialCreateRequest: built.body,
+    }));
+}
+export async function runGeneratedCredentialGet(profile, environmentId, credentialId, options) {
+    const envId = environmentId.trim();
+    if (!envId) {
+        process.stderr.write("Missing required argument: environment-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const credId = credentialId.trim();
+    if (!credId) {
+        process.stderr.write("Missing required argument: credential-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2EnvironmentsCredentialsApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.getEnvironmentCredentialCorpusEnvironmentsEnvironmentIdCredentialsCredentialIdGetRaw({
+        ...headers,
+        environmentId: envId,
+        credentialId: credId,
+    }));
+}
+export async function runProxyOperation(profile, discovered, body, options) {
+    const result = await callCicdGateway(profile, {
+        endpoint: discovered.path,
+        method: discovered.method.toUpperCase(),
+        body: discovered.method === "get" ? {} : body,
+    }, options);
+    if (result.status >= 200 && result.status < 300) {
+        writeCicdSuccess(result);
+        return;
+    }
+    handleCicdFailure(result);
+}
+export async function runOpenApiCreateWithBridge(profile, version, commandTag, opts, options) {
+    const doc = loadBundledOpenApi(version);
+    const discovered = discoverOperation(doc, commandTag);
+    if (!discovered) {
+        process.stderr.write(`No "${commandTag}" operation found in bundled OpenAPI spec.\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const built = buildBodyFromOperation(doc, discovered.operation, opts);
+    if (!built.ok) {
+        process.stderr.write(`${built.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const endpoint = options?.endpoint?.trim() ?? discovered.path;
+    const method = (options?.method?.trim() ??
+        discovered.method.toUpperCase()).toUpperCase();
+    const result = await callCicdGateway(profile, { endpoint, method, body: built.body }, options);
+    if (result.status >= 200 && result.status < 300) {
+        writeCicdSuccess(result);
+        return;
+    }
+    handleCicdFailure(result);
+}
+export async function runGeneratedMetadataIndexRefresh(profile, opts, options) {
+    const doc = loadBundledOpenApi("v2");
+    const discovered = discoverOperation(doc, "metadata-index-refresh");
+    if (!discovered) {
+        process.stderr.write('No "metadata index refresh" operation found in cicd_openapi.v2.json.\n');
+        process.exitCode = 1;
+        return;
+    }
+    const built = buildRefreshMetadataIndexRequest(opts);
+    if (!built.ok) {
+        process.stderr.write(`${built.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2MetadataApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    const postResult = await invokeGenerated(() => api.refreshMetadataIndexReleaseMetadataIndexRefreshPostRaw({
+        ...headers,
+        refreshMetadataIndexRequest: built.body,
+    }), { silent: Boolean(opts.wait) });
+    if (!postResult)
+        return;
+    if (!opts.wait)
+        return;
+    const eventId = postResult.data?.eventId;
+    if (!eventId?.trim()) {
+        process.stderr.write("Missing eventId in refresh response\n");
+        process.exitCode = 1;
+        return;
+    }
+    await pollMetadataIndexRefreshStatus(profile, eventId, {
+        ...options,
+        timeoutSeconds: opts.timeoutSeconds,
+    });
+}
+export async function runGeneratedMetadataIndexRefreshStatus(profile, eventId, options) {
+    const doc = loadBundledOpenApi("v2");
+    const discovered = discoverOperation(doc, "metadata-index-refresh-status");
+    if (!discovered) {
+        process.stderr.write('No "metadata index refresh status" operation found in cicd_openapi.v2.json.\n');
+        process.exitCode = 1;
+        return;
+    }
+    const id = eventId.trim();
+    if (!id) {
+        process.stderr.write("Missing required argument: event-id\n");
+        process.exitCode = 1;
+        return;
+    }
+    await fetchMetadataIndexRefreshStatus(profile, id, options);
+}
+export async function runGeneratedMetadataIndexSearch(profile, opts, options) {
+    const doc = loadBundledOpenApi("v2");
+    const discovered = discoverOperation(doc, "metadata-index-search");
+    if (!discovered) {
+        process.stderr.write('No "metadata index search" operation found in cicd_openapi.v2.json.\n');
+        process.exitCode = 1;
+        return;
+    }
+    const built = buildMetadataIndexSearchRequest(opts);
+    if (!built.ok) {
+        process.stderr.write(`${built.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2MetadataApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.getMetadataIndexReleaseMetadataIndexPostRaw({
+        ...headers,
+        metadataIndexRequest: built.body,
+    }));
+}
+export async function runGeneratedMetadataTypes(profile, environmentId, credentialId, options) {
+    const envId = environmentId.trim();
+    if (!envId) {
+        process.stderr.write("Missing required option: --environment\n");
+        process.exitCode = 1;
+        return;
+    }
+    const credId = credentialId.trim();
+    if (!credId) {
+        process.stderr.write("Missing required option: --credential\n");
+        process.exitCode = 1;
+        return;
+    }
+    const moduleTypeResult = resolveModuleType(options?.moduleType);
+    if (!moduleTypeResult.ok) {
+        process.stderr.write(`${moduleTypeResult.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2MetadataApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.getMetadataTypesInSystemReleaseMetadataTypesSystemIdGetRaw({
+        ...headers,
+        systemId: envId,
+        credentialId: credId,
+        ...(moduleTypeResult.moduleType
+            ? { moduleTypes: [moduleTypeResult.moduleType] }
+            : {}),
+    }));
+}
+export async function runGeneratedMetadataUsers(profile, environmentId, credentialId, options) {
+    const envId = environmentId.trim();
+    if (!envId) {
+        process.stderr.write("Missing required option: --environment\n");
+        process.exitCode = 1;
+        return;
+    }
+    const credId = credentialId.trim();
+    if (!credId) {
+        process.stderr.write("Missing required option: --credential\n");
+        process.exitCode = 1;
+        return;
+    }
+    const moduleTypeResult = resolveModuleType(options?.moduleType);
+    if (!moduleTypeResult.ok) {
+        process.stderr.write(`${moduleTypeResult.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2MetadataApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.getUsersOnSystemReleaseMetadataUsersSystemIdGetRaw({
+        ...headers,
+        systemId: envId,
+        credentialId: credId,
+        ...(moduleTypeResult.moduleType
+            ? { moduleTypes: [moduleTypeResult.moduleType] }
+            : {}),
+    }));
+}
+export async function runGeneratedDeploySelection(profile, opts, options) {
+    const doc = loadBundledOpenApi("v2");
+    const discovered = discoverOperation(doc, "deploy-selection");
+    if (!discovered) {
+        process.stderr.write('No "deploy-selection" operation found in cicd_openapi.v2.json.\n');
+        process.exitCode = 1;
+        return;
+    }
+    const built = buildDeploySelectionRequest(opts);
+    if (!built.ok) {
+        process.stderr.write(`${built.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const result = await callCicdGateway(profile, {
+        endpoint: discovered.path,
+        method: discovered.method.toUpperCase(),
+        body: built.body,
+    }, options);
+    if (result.status >= 200 && result.status < 300) {
+        writeCicdSuccess(result);
+        return;
+    }
+    handleCicdFailure(result);
+}
+export async function runGeneratedCommit(profile, opts, options) {
+    const doc = loadBundledOpenApi("v2");
+    const discovered = discoverOperation(doc, "commit");
+    if (!discovered) {
+        process.stderr.write('No "commit" operation found in cicd_openapi.v2.json.\n');
+        process.exitCode = 1;
+        return;
+    }
+    const built = buildCommitRequest(opts);
+    if (!built.ok) {
+        process.stderr.write(`${built.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const api = createCicdV2ActionsApi(profile, options);
+    const headers = gatewayHeaderParams(profile);
+    await invokeGenerated(() => api.submitCommitReleaseActionsCommitPostRaw({
+        ...headers,
+        commitRequestSchema: built.body,
+    }));
+}
+//# sourceMappingURL=openapi-command.js.map