@cat-indev/catops-cli 0.0.1-alpha.10 → 0.0.1-alpha.12

package/README.md

@@ -5,7 +5,7 @@ Framework para pipelines DevOps, escrito en **TypeScript** (100% usable desde Ja
 Trae:
 
 - Un **ExecutionContext** compartido (`flags`, `params`, `env`, `vars`, `results`, `logger`, `services`, `notifier`) para que ninguna task tenga que recibir parámetros manualmente.
-- **15 servicios** listos (`shell`, `docker`, `git`, `kubectl`, `helm`, `npm`, `archive`, `terraform`, `ansible`, `argocd`, `tekton`, `oc`, `az`, `azdo`, `http`) + un **cliente REST API** para Azure DevOps (`AzureDevOpsApi`) + un **motor de pipelines** declarativo con dependencias (`Pipeline`).
+- **16 servicios** listos (`shell`, `docker`, `git`, `kubectl`, `helm`, `npm`, `archive`, `terraform`, `ansible`, `argocd`, `tekton`, `oc`, `az`, `azdo`, `http`, `yaml`) + un **cliente REST API** para Azure DevOps (`AzureDevOpsApi`) + un **motor de pipelines** declarativo con dependencias (`Pipeline`).
 - **Servicio HTTP** con interceptores de request/response, registry de agentes nombrados, configuración global, query params, dry-run y timeout.
 - **Menús interactivos** con navegación anidada y **selección automática por flag** (para correr pipelines sin prompts, ideal para CI).
 - **retry / timeout / dryRun** en cada comando de shell.
@@ -52,10 +52,10 @@ Cualquiera de las 4 deja disponibles dos cosas en el proyecto consumidor:
 
 1. La librería, tanto desde TS como desde JS puro:
    ```typescript
-   import { Context, Menu, services, type MenuDefinition } from "catops-cli";
+   import { Context, Menu, services, YamlService, type MenuDefinition } from "catops-cli";
    ```
    ```javascript
-   const { Context, Menu, services } = require("catops-cli");
+   const { Context, Menu, services, YamlService } = require("catops-cli");
    ```
 2. El binario: `npx catops-cli` (o `catops-cli` si lo instalaste global con `-g`).
 
@@ -89,7 +89,8 @@ src/
     http.ts           -> cliente HTTP con interceptores de request/response, múltiples instancias
     http-types.ts     -> tipos del servicio HTTP (HttpRequest, HttpResponse, interceptors, ...)
     docker.ts, git.ts, kubectl.ts, helm.ts, npm.ts, archive.ts
-    terraform.ts, ansible.ts, argocd.ts, tekton.ts, oc.ts,     az.ts, azdo.ts, azdo-api.ts, pipeline.ts
+    terraform.ts, ansible.ts, argocd.ts, tekton.ts, oc.ts, az.ts, azdo.ts, azdo-api.ts, pipeline.ts
+    yaml.ts              -> YamlService: manipulación de archivos YAML con prepare(), multidocument, comentarios
     index.ts           -> registra todos los servicios anteriores (ServicesRegistry)
   index.ts             -> entry point público: Context, Menu, Notifier, senders, classifiers, messages, services, http, tipos
   bin/
@@ -100,8 +101,8 @@ test/
     context.test.js, shell.test.js, services.test.js, menu-selector.test.js,
   notifier.test.js, senders.test.js, hooks-integration.test.js,
   http.test.js, kubectl.test.js, oc.test.js, deployment-group.test.js,
-  exec-options-passthrough.test.js, azdo-api.test.js, pipeline.test.js,
-  service-notify.test.js
+  exec-options-passthrough.test.js,   azdo-api.test.js, pipeline.test.js,
+  service-notify.test.js, yaml.test.js
 ```
 
 ## Uso rápido: menú con `devops.pipeline.js` + el bin
@@ -1223,6 +1224,170 @@ const docker = ctx.wrap(ctx.services.docker, "docker");
 docker.version; // pasa directo, sin proxy
 ```
 
+## Servicio YAML: manipulación de archivos de configuración (`ctx.services.yaml`)
+
+Un servicio para leer, modificar y serializar archivos YAML con soporte para operaciones declarativas, comentarios, y documentos múltiples.
+
+### Uso básico
+
+```typescript
+// Parsear YAML desde string
+ctx.services.yaml.fromYaml(`
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: app-config
+data:
+  ENV: production
+`);
+
+// Obtener valores
+ctx.services.yaml.yamlGet("metadata.name");            // "app-config"
+ctx.services.yaml.yamlGet("data.ENV", "default");     // "production"
+
+// Asignar valores (crea paths nuevos si no existen)
+ctx.services.yaml.yamlSet(["data", "DEBUG"], "false");
+
+// Serializar a YAML
+const yamlString = ctx.services.yaml.yamlify();
+
+// Serializar a JSON
+const jsonString = ctx.services.yaml.stringify();
+```
+
+### Trabajar con JSON
+
+```typescript
+// Convertir JSON a YAML interno
+ctx.services.yaml.fromJson({
+    apiVersion: "v1",
+    kind: "Service",
+    metadata: { name: "api-service" }
+});
+
+// Obtener como objeto JSON
+const obj = ctx.services.yaml.jsonify();
+```
+
+### Arrays y omisión de keys
+
+```typescript
+// Agregar elementos a un array
+ctx.services.yaml.yamlPush(["data", "ALLOWED_HOSTS"], ["host1.example.com", "host2.example.com"]);
+
+// Concatenar al inicio de un string
+ctx.services.yaml.yamlConcatInitAndSet(["data", "PREFIX"], "prod-");  // "prod-valor-anterior"
+
+// Eliminar paths del documento
+ctx.services.yaml.yamlOmit(["data", "DEBUG", "data", "TEMP"]);
+```
+
+### Comentarios
+
+```typescript
+// Agregar commentBefore a un nodo específico
+ctx.services.yaml.comment("Configuración del backend", ["data", "BACKEND_URL"]);
+```
+
+### Declaraciones batch con `prepare()`
+
+`prepare()` permite aplicar múltiples mutaciones en una sola llamada — ideal para transformaciones complejas:
+
+```typescript
+ctx.services.yaml.prepare({
+    // Asignar valores por path
+    $set: [
+        { path: "apiVersion", value: "v1" },
+        { path: "metadata.labels.env", value: "production" }
+    ],
+
+    // Agregar a arrays
+    $push: [
+        { path: "spec.containers", value: { name: "sidecar", image: "proxy:v1" } }
+    ],
+
+    // Fusionar objetos existentes
+    $spread: [
+        { path: "metadata.labels", value: { version: "v2", team: "platform" } }
+    ],
+
+    // Asignar el mismo valor a múltiples paths
+    $superSet: {
+        value: "true",
+        $set: ["data.ENABLE_FEATURE_A", "data.ENABLE_FEATURE_B"],
+        $init: ["data.PREFIX"]  // concatena al inicio en vez de reemplazar
+    },
+
+    // Asignar valores por path (shorthand)
+    $merge: {
+        "data.RETRY_COUNT": "3",
+        "data.TIMEOUT": "30000"
+    },
+
+    // Eliminar keys
+    $delete: ["data.DEBUG", "data.TEMP"]
+});
+```
+
+### Documentos múltiples
+
+Para archivos YAML con múltiples documentos separados por `---`:
+
+```typescript
+// Crear documentos múltiples
+ctx.services.yaml.multidocument(
+    { yaml: "kind: Deployment\nmetadata:\n  name: api", name: "deployment" },
+    { replicas: 3 }  // apply extra values sobre el nuevo doc
+);
+
+ctx.services.yaml.multidocument(
+    { yaml: "kind: Service\nmetadata:\n  name: api-svc", name: "service" }
+);
+
+// Cambiar entre documentos
+ctx.services.yaml.use("deployment");
+console.log(ctx.services.yaml.yamlify());  // imprime el doc "deployment"
+
+ctx.services.yaml.use("service");
+console.log(ctx.services.yaml.yamlify());  // imprime el doc "service"
+
+// Verificar si un documento existe
+ctx.services.yaml.existDocument("deployment");  // true
+```
+
+### Clonar
+
+```typescript
+const clone = ctx.services.yaml.clone();
+// clone es independiente — modificar uno no afecta al otro
+```
+
+### Parsear YAML vacío
+
+```typescript
+ctx.services.yaml.fromYaml("");  // crea documento vacío, no lanza error
+```
+
+### Ejemplo completo: modificar un Deployment de Kubernetes
+
+```typescript
+ctx.services.yaml.fromYaml(readFileSync("deployment.yaml", "utf8"));
+
+ctx.services.yaml.prepare({
+    $set: [
+        { path: "spec.template.metadata.labels.version", value: "v2.1.0" },
+        { path: "spec.template.spec.containers.0.image", value: "registry/app:v2.1.0" }
+    ],
+    $spread: [
+        { path: "spec.template.metadata.annotations", value: { "deployed-at": new Date().toISOString() } }
+    ],
+    $delete: ["spec.template.spec.initContainers"]
+});
+
+const updatedYaml = ctx.services.yaml.yamlify();
+writeFileSync("deployment.yaml", updatedYaml);
+```
+
 ## Tests
 
 ```bash
@@ -1245,6 +1410,7 @@ npm test
 - `azdo-api.test.js` — AzureDevOpsApi contra mock server: proyectos, repos, branches, commits, PRs, builds, pipelines, work items, overrides
 - `pipeline.test.js` — Pipeline motor: stages/jobs/tasks, dependencias cross-level con paths dotted, resultados jerárquicos (stage.job.task), fluent API, registry, reset, ctx access, detección de tipo por propiedad, PipelineResultsAccessor
 - `service-notify.test.js` — ServiceError, ctx.wrap(), Notifier con service/method/args, classifiers.byService/messages.byService, unwrap de ServiceError en byCommand/byPattern/byRule, integración completa, backward compat
+- `yaml.test.js` — YamlService: fromYaml/fromJson, yamlGet/yamlSet/yamlPush/yamlOmit, comment(), prepare() con $set/$push/$spread/$superSet/$merge/$delete, multidocument/use/clone
 
 ## Siguientes pasos posibles
 
@@ -1252,3 +1418,4 @@ npm test
 - Agregar más plugins (`ansible-lint`, `trivy`, `sonar-scanner`) con el mismo patrón que `terraform.ts`/`docker.ts`.
 - CI propio (GitHub Actions/Azure Pipelines) que corra `npm test` en cada PR antes de `npm publish`.
 - `--catch=throw` (o similar) para que un item de menú fallido mate el proceso completo en vez de solo loguear y seguir — útil corriendo vía `--menu-selector` dentro de un step de Azure Pipelines.
+- Exportar tipos YAML (`YamlPrepareActions`) y crear helpers para templates comunes (Kubernetes manifests, Helm values, etc.).

package/dist/index.d.ts

@@ -8,10 +8,12 @@ export { services } from "./services";
 export type { ServicesRegistry } from "./services";
 export { PipelineRegistry, Pipeline, PipelineStage, PipelineJob, PipelineTask, PipelineResultsAccessor } from "./services/pipeline";
 export type { PipelineConfig, PipelineStageConfig, PipelineJobConfig, PipelineTaskConfig, PipelineTaskBase, CallbackTaskConfig, PipelineRunResult, PipelineEntityStatus } from "./services/pipeline";
+export { YamlService } from "./services/yaml";
+export type { YamlPrepareActions } from "./services/yaml";
 export { http, HttpService, HttpRegistry } from "./services/http";
 export type { HttpMethod, HttpRequest, HttpResponse, HttpServiceConfig, RequestInterceptor, ResponseInterceptor, RequestContext, ResponseContext } from "./services/http-types";
 export { AzureDevOpsApi } from "./services/azdo-api";
-export type { AzureDevOpsApiConfig, AzdoRequestOptions, AzdoProject, AzdoGitRepository, AzdoGitBranch, AzdoGitCommitRef, AzdoGitAuthor, AzdoGitPullRequest, AzdoBuildDefinition, AzdoBuild, AzdoPipeline, AzdoWorkItem, AzdoListResponse } from "./services/azdo-api";
+export type { AzureDevOpsApiConfig, AzdoRequestOptions, AzdoProject, AzdoGitRepository, AzdoGitBranch, AzdoGitCommitRef, AzdoGitAuthor, AzdoGitPullRequest, AzdoBuildDefinition, AzdoBuild, AzdoPipeline, AzdoWorkItem, AzdoListResponse, AzdoWebHookSubscription, AzdoEnvironment, AzdoIdentityGroup, AzdoPolicyConfiguration, AzdoAgentPool, AzdoAgentQueue, AzdoVariableGroup, AzdoBuildFolder, AzdoServiceEndpoint, AzdoGitRef, AzdoGitTag, AzdoGitItem } from "./services/azdo-api";
 export { Notifier } from "./core/Notifier";
 export * as senders from "./core/senders";
 export * as classifiers from "./core/classifiers";

package/dist/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceError = exports.messages = exports.classifiers = exports.senders = exports.Notifier = exports.AzureDevOpsApi = exports.HttpRegistry = exports.HttpService = exports.http = exports.PipelineResultsAccessor = exports.PipelineTask = exports.PipelineJob = exports.PipelineStage = exports.Pipeline = exports.PipelineRegistry = exports.services = exports.prompt = exports.logger = exports.Menu = exports.Context = void 0;
+exports.ServiceError = exports.messages = exports.classifiers = exports.senders = exports.Notifier = exports.AzureDevOpsApi = exports.HttpRegistry = exports.HttpService = exports.http = exports.YamlService = exports.PipelineResultsAccessor = exports.PipelineTask = exports.PipelineJob = exports.PipelineStage = exports.Pipeline = exports.PipelineRegistry = exports.services = exports.prompt = exports.logger = exports.Menu = exports.Context = void 0;
 var Context_1 = require("./core/Context");
 Object.defineProperty(exports, "Context", { enumerable: true, get: function () { return Context_1.Context; } });
 var Menu_1 = require("./core/Menu");
@@ -50,6 +50,8 @@ Object.defineProperty(exports, "PipelineStage", { enumerable: true, get: functio
 Object.defineProperty(exports, "PipelineJob", { enumerable: true, get: function () { return pipeline_1.PipelineJob; } });
 Object.defineProperty(exports, "PipelineTask", { enumerable: true, get: function () { return pipeline_1.PipelineTask; } });
 Object.defineProperty(exports, "PipelineResultsAccessor", { enumerable: true, get: function () { return pipeline_1.PipelineResultsAccessor; } });
+var yaml_1 = require("./services/yaml");
+Object.defineProperty(exports, "YamlService", { enumerable: true, get: function () { return yaml_1.YamlService; } });
 var http_1 = require("./services/http");
 Object.defineProperty(exports, "http", { enumerable: true, get: function () { return http_1.http; } });
 Object.defineProperty(exports, "HttpService", { enumerable: true, get: function () { return http_1.HttpService; } });

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0CAAyC;AAAhC,kGAAA,OAAO,OAAA;AAGhB,oCAAmC;AAA1B,4FAAA,IAAI,OAAA;AAEb,wCAAuC;AAA9B,gGAAA,MAAM,OAAA;AAGf,wDAAwC;AAExC,uCAAsC;AAA7B,oGAAA,QAAQ,OAAA;AAGjB,gDAAoI;AAA3H,4GAAA,gBAAgB,OAAA;AAAE,oGAAA,QAAQ,OAAA;AAAE,yGAAA,aAAa,OAAA;AAAE,uGAAA,WAAW,OAAA;AAAE,wGAAA,YAAY,OAAA;AAAE,mHAAA,uBAAuB,OAAA;AAYtG,wCAAkE;AAAzD,4FAAA,IAAI,OAAA;AAAE,mGAAA,WAAW,OAAA;AAAE,oGAAA,YAAY,OAAA;AAYxC,gDAAqD;AAA5C,0GAAA,cAAc,OAAA;AAiBvB,4CAA2C;AAAlC,oGAAA,QAAQ,OAAA;AACjB,0DAA0C;AAC1C,kEAAkD;AAClD,4DAA4C;AAmB5C,sCAA4C;AAAnC,qGAAA,YAAY,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0CAAyC;AAAhC,kGAAA,OAAO,OAAA;AAGhB,oCAAmC;AAA1B,4FAAA,IAAI,OAAA;AAEb,wCAAuC;AAA9B,gGAAA,MAAM,OAAA;AAGf,wDAAwC;AAExC,uCAAsC;AAA7B,oGAAA,QAAQ,OAAA;AAGjB,gDAAoI;AAA3H,4GAAA,gBAAgB,OAAA;AAAE,oGAAA,QAAQ,OAAA;AAAE,yGAAA,aAAa,OAAA;AAAE,uGAAA,WAAW,OAAA;AAAE,wGAAA,YAAY,OAAA;AAAE,mHAAA,uBAAuB,OAAA;AAYtG,wCAA8C;AAArC,mGAAA,WAAW,OAAA;AAGpB,wCAAkE;AAAzD,4FAAA,IAAI,OAAA;AAAE,mGAAA,WAAW,OAAA;AAAE,oGAAA,YAAY,OAAA;AAYxC,gDAAqD;AAA5C,0GAAA,cAAc,OAAA;AA6BvB,4CAA2C;AAAlC,oGAAA,QAAQ,OAAA;AACjB,0DAA0C;AAC1C,kEAAkD;AAClD,4DAA4C;AAmB5C,sCAA4C;AAAnC,qGAAA,YAAY,OAAA"}

package/dist/services/azdo-api.d.ts

@@ -120,6 +120,97 @@ export interface AzdoListResponse<T> {
     count: number;
     value: T[];
 }
+export interface AzdoWebHookSubscription {
+    id: number;
+    publisherId: string;
+    publisherInputs: Record<string, string>;
+    consumerInputs: Record<string, string>;
+    eventType: string;
+    resourceVersion: string;
+    scope: number;
+}
+export interface AzdoEnvironment {
+    id: number;
+    name: string;
+    description: string;
+    project: AzdoProject;
+}
+export interface AzdoIdentityGroup {
+    displayName: string;
+    samAccountName: string;
+    localId: string;
+    subjectDescriptor: string;
+    imageUrl?: string;
+    uniqueName?: string;
+    metaType?: string;
+    sid?: string;
+    mailAddress?: string;
+}
+export interface AzdoPolicyConfiguration {
+    id: number;
+    url: string;
+    type: {
+        id: string;
+        displayName: string;
+    };
+    isEnabled: boolean;
+    isBlocking: boolean;
+    settings: Record<string, unknown>;
+}
+export interface AzdoAgentPool {
+    id: number;
+    name: string;
+    url: string;
+    size: number;
+    isHosted: boolean;
+}
+export interface AzdoAgentQueue {
+    id: number;
+    name: string;
+    pool: AzdoAgentPool;
+    url: string;
+}
+export interface AzdoVariableGroup {
+    id: number;
+    name: string;
+    variables: Record<string, {
+        value?: string;
+        isSecret?: boolean;
+    }>;
+    type: string;
+}
+export interface AzdoBuildFolder {
+    path: string;
+    project: AzdoProject;
+}
+export interface AzdoServiceEndpoint {
+    id: string;
+    name: string;
+    type: string;
+    url: string;
+    projectReferences: Array<{
+        id: string;
+        name: string;
+    }>;
+}
+export interface AzdoGitRef {
+    name: string;
+    objectId: string;
+    peeledObjectId?: string;
+    creator?: AzdoGitAuthor;
+}
+export interface AzdoGitTag {
+    name: string;
+    ref: string;
+    objectId: string;
+    creator?: AzdoGitAuthor;
+    peeledObjectId?: string;
+}
+export interface AzdoGitItem {
+    path: string;
+    content?: string;
+    contentType?: string;
+}
 export declare class AzureDevOpsApi {
     private baseUrl;
     private pat;
@@ -209,5 +300,126 @@ export declare class AzureDevOpsApi {
             url: string;
         }>;
     }>>;
+    /** Verifica si un repositorio existe. Devuelve el repo o `undefined`. */
+    repoExists(project: string | undefined, repoName: string, opts?: AzdoRequestOptions): Promise<AzdoGitRepository | undefined>;
+    /** Crea un repositorio en un proyecto. */
+    createRepository(projectName: string, projectId: string, repoName: string, opts?: AzdoRequestOptions): Promise<HttpResponse<AzdoGitRepository>>;
+    /** Crea una branch nueva a partir de un commit ID. */
+    createBranch(project: string | undefined, repoName: string, branchName: string, fromObjectId: string, opts?: AzdoRequestOptions): Promise<HttpResponse<AzdoGitRef[]>>;
+    /** Obtiene el último commit de un repo. Devuelve `null` si no hay commits. */
+    getLatestCommit(project: string | undefined, repoNameOrId: string, opts?: AzdoRequestOptions): Promise<{
+        commitId: string;
+        message: string;
+        date: string;
+        author: {
+            name: string;
+            date: string;
+        };
+    } | null>;
+    /** Verifica si un archivo existe en una branch. Devuelve el item o `undefined`. */
+    fileExists(project: string | undefined, repoName: string, branchName: string, filePath: string, opts?: AzdoRequestOptions): Promise<AzdoGitItem | undefined>;
+    /** Crea o actualiza un archivo en una branch (push de un solo archivo). */
+    createOrUpdateFile(options: {
+        project: string | undefined;
+        repo: string;
+        branch: string;
+        filePath: string;
+        fileContent: string | Buffer;
+        comment?: string;
+    }, opts?: AzdoRequestOptions): Promise<HttpResponse<unknown>>;
+    /**
+     * Crea un archivo en un repo. Si el contenido es una de las plantillas
+     * conocidas (ej. `$README:TEMPLATE`), genera un README.md con el contenido
+     * por defecto.
+     */
+    createFileInRepo(project: string | undefined, repo: string, branch: string, fileName: string, filePath: string, fileContent: string, opts?: AzdoRequestOptions): Promise<HttpResponse<unknown>>;
+    /** Crea un repositorio y lo inicializa con un README. */
+    createAndInitRepository(projectName: string, projectId: string, repository: string, opts?: AzdoRequestOptions): Promise<AzdoGitRepository>;
+    /** Hace un push con múltiples cambios (add/edit/delete) en un solo commit. */
+    pushChanges(options: {
+        project: string | undefined;
+        repository: string;
+        branch: string;
+        changes: Array<{
+            changeType: string;
+            item: {
+                path: string;
+            };
+            newContent?: {
+                content: string;
+                contentType: string;
+            };
+        }>;
+        comment: string;
+    }, opts?: AzdoRequestOptions): Promise<HttpResponse<unknown>>;
+    /** Descarga un repositorio completo como buffer ZIP. */
+    downloadRepositoryZip(options: {
+        project: string;
+        repository: string;
+        branch: string;
+        scopePath?: string;
+    }, opts?: AzdoRequestOptions): Promise<HttpResponse<unknown>>;
+    /** Verifica si existe un webhook de push para un repo/branch/URL dados. */
+    webhookExists(projectId: string, repositoryId: string, branchName: string, webhookUrl: string, opts?: AzdoRequestOptions): Promise<AzdoWebHookSubscription | undefined>;
+    /** Crea un webhook de push para un repositorio. */
+    createWebhook(projectId: string, repoId: string, sourceBranch: string, webhookUrl: string, opts?: AzdoRequestOptions): Promise<HttpResponse<AzdoWebHookSubscription>>;
+    /** Crea un environment en un proyecto. */
+    createEnvironment(project: string | undefined, name: string, description?: string, opts?: AzdoRequestOptions): Promise<HttpResponse<AzdoEnvironment>>;
+    /** Busca un grupo de identidades por nombre (SAM account name). */
+    findIdentityGroup(groupName: string, opts?: AzdoRequestOptions): Promise<AzdoIdentityGroup>;
+    /** Crea una approval check para un environment. */
+    createEnvironmentApproval(project: string | undefined, environmentId: number, environmentName: string, approver: AzdoIdentityGroup, opts?: AzdoRequestOptions): Promise<HttpResponse<unknown>>;
+    /**
+     * Crea un environment con approvals.
+     * Si `approverGroup` es `"none"`, no agrega approvals.
+     */
+    createEnvironmentWithApprovals(options: {
+        project: string | undefined;
+        environmentName: string;
+        description?: string;
+        approverGroup: string;
+    }, opts?: AzdoRequestOptions): Promise<AzdoEnvironment>;
+    /** Crea una política de validación de email del committer. */
+    applyCommitterRegexPermissions(projectId: string, opts?: AzdoRequestOptions): Promise<HttpResponse<number>>;
+    /** Actualiza una política de validación de email del committer. */
+    updateCommitterRegexPermissions(projectId: string, policyId: number, allowedEmailPatterns: string[], opts?: AzdoRequestOptions): Promise<HttpResponse<number>>;
+    /** Obtiene los grupos con permisos de contribuidor del proyecto. */
+    getContributorGroups(projectId: string, projectName: string, opts?: AzdoRequestOptions): Promise<AzdoIdentityGroup[]>;
+    /** Deniega permisos a una entidad por SID. */
+    denyPermission(projectId: string, entityId: string, permissionCode: number, opts?: AzdoRequestOptions): Promise<HttpResponse<unknown>>;
+    /** Deniega permisos a un usuario por email. */
+    denyPermissionByEmail(projectId: string, userEmail: string, permissionCode: number, opts?: AzdoRequestOptions): Promise<HttpResponse<unknown>>;
+    /**
+     * Aplica permisos a todos los proyectos: crea la política de regex,
+     * obtiene los grupos, y deniega los permisos de Force Push y Create Branch.
+     */
+    applyPermissions(opts?: AzdoRequestOptions): Promise<Array<{
+        project: string;
+        groupsProcessed: number;
+    }>>;
+    /** Asocia un agent pool existente a un proyecto (crea una queue). */
+    addAgentPoolToProject(project: string | undefined, agentPoolName: string, opts?: AzdoRequestOptions): Promise<HttpResponse<AzdoAgentQueue>>;
+    /** Autoriza todos los pipelines para usar una queue. */
+    authorizeAgentPool(project: string | undefined, queueId: number, opts?: AzdoRequestOptions): Promise<HttpResponse<unknown>>;
+    /** Crea un variable group. Si ya existe con el mismo nombre, lo devuelve sin crear. */
+    createVariableGroup(project: string | undefined, name: string, variables?: Record<string, {
+        value?: string;
+        isSecret?: boolean;
+    }>, opts?: AzdoRequestOptions): Promise<AzdoVariableGroup>;
+    /** Crea una carpeta de build. Si ya existe, la devuelve. */
+    createBuildFolder(project: string | undefined, folderPath: string, opts?: AzdoRequestOptions): Promise<AzdoBuildFolder>;
+    /** Crea un pipeline YAML asociado a un repositorio. */
+    createPipeline(options: {
+        project: string | undefined;
+        name: string;
+        folder?: string;
+        repository: string;
+        yamlPath: string;
+        defaultBranch?: string;
+    }, opts?: AzdoRequestOptions): Promise<HttpResponse<unknown>>;
+    /** Comparte un service endpoint con un proyecto. */
+    shareServiceConnection(project: string, resourceId: string, resourceName: string, opts?: AzdoRequestOptions): Promise<HttpResponse<unknown>>;
+    /** Lista todas las tags de un repositorio. */
+    getTags(project: string | undefined, repository: string, opts?: AzdoRequestOptions): Promise<AzdoGitTag[]>;
 }
 export {};