@artifact-keeper/sdk 1.1.0-dev.2 → 1.1.0-rc.2

package/src/types.gen.ts

@@ -20,6 +20,10 @@ export type AddLabelRequest = {
     value?: string;
 };
 
+export type AddPeerLabelRequest = {
+    value?: string;
+};
+
 export type AddVirtualMemberRequest = {
     member_key: string;
     priority?: number | null;
@@ -70,6 +74,87 @@ export type ApiTokenResponse = {
     token_prefix: string;
 };
 
+export type ApprovalHistoryQuery = {
+    page?: number | null;
+    per_page?: number | null;
+    source_repository?: string | null;
+    status?: string | null;
+};
+
+export type ApprovalListResponse = {
+    items: Array<ApprovalResponse>;
+    pagination: Pagination;
+};
+
+export type ApprovalRequest = {
+    /**
+     * Artifact ID to promote
+     */
+    artifact_id: string;
+    /**
+     * Free-text justification
+     */
+    notes?: string | null;
+    /**
+     * Skip policy evaluation
+     */
+    skip_policy_check?: boolean;
+    /**
+     * Source staging repository key
+     */
+    source_repository: string;
+    /**
+     * Target release repository key
+     */
+    target_repository: string;
+};
+
+export type ApprovalResponse = {
+    artifact_id: string;
+    id: string;
+    notes?: string | null;
+    policy_result?: {
+        [key: string]: unknown;
+    } | null;
+    requested_at: string;
+    requested_by: string;
+    review_notes?: string | null;
+    reviewed_at?: string | null;
+    reviewed_by?: string | null;
+    source_repository: string;
+    status: string;
+    target_repository: string;
+};
+
+export type ArtifactEvalEntry = {
+    artifact_id: string;
+    passed: boolean;
+    violations: Array<string>;
+};
+
+export type ArtifactFilterSchema = {
+    exclude_paths?: Array<string>;
+    include_paths?: Array<string>;
+    max_age_days?: number | null;
+    max_size_bytes?: number | null;
+};
+
+export type ArtifactHealthResponse = {
+    artifact_id: string;
+    checks: Array<CheckSummary>;
+    checks_passed: number;
+    checks_total: number;
+    critical_issues: number;
+    health_grade: string;
+    health_score: number;
+    last_checked_at?: string | null;
+    license_score?: number | null;
+    metadata_score?: number | null;
+    quality_score?: number | null;
+    security_score?: number | null;
+    total_issues: number;
+};
+
 export type ArtifactListResponse = {
     items: Array<ArtifactResponse>;
     pagination: Pagination;
@@ -244,6 +329,15 @@ export type BuildRow = {
     updated_at: string;
 };
 
+export type BulkEvaluationResponse = {
+    failed: number;
+    passed: number;
+    results: Array<ArtifactEvalEntry>;
+    rule_id: string;
+    rule_name: string;
+    total_artifacts: number;
+};
+
 export type BulkPromoteRequest = {
     artifact_ids: Array<string>;
     notes?: string | null;
@@ -268,11 +362,44 @@ export type CheckLicenseComplianceRequest = {
     repository_id?: string | null;
 };
 
+export type CheckResponse = {
+    artifact_id: string;
+    check_type: string;
+    checker_version?: string | null;
+    completed_at?: string | null;
+    created_at: string;
+    critical_count: number;
+    details?: {
+        [key: string]: unknown;
+    } | null;
+    error_message?: string | null;
+    high_count: number;
+    id: string;
+    info_count: number;
+    issues_count: number;
+    low_count: number;
+    medium_count: number;
+    passed?: boolean | null;
+    repository_id: string;
+    score?: number | null;
+    started_at?: string | null;
+    status: string;
+};
+
 export type CheckStatus = {
     message?: string | null;
     status: string;
 };
 
+export type CheckSummary = {
+    check_type: string;
+    completed_at?: string | null;
+    issues_count: number;
+    passed?: boolean | null;
+    score?: number | null;
+    status: string;
+};
+
 export type ChecksumArtifact = {
     checksum_sha256: string;
     content_type: string;
@@ -451,6 +578,23 @@ export type CreateConnectionRequest = {
     url: string;
 };
 
+export type CreateGateRequest = {
+    action?: string;
+    description?: string | null;
+    enforce_on_download?: boolean;
+    enforce_on_promotion?: boolean;
+    max_critical_issues?: number | null;
+    max_high_issues?: number | null;
+    max_medium_issues?: number | null;
+    min_health_score?: number | null;
+    min_metadata_score?: number | null;
+    min_quality_score?: number | null;
+    min_security_score?: number | null;
+    name: string;
+    repository_id?: string | null;
+    required_checks?: Array<string>;
+};
+
 export type CreateGroupRequest = {
     description?: string | null;
     name: string;
@@ -522,9 +666,12 @@ export type CreatePermissionRequest = {
 export type CreatePolicyRequest = {
     block_on_fail: boolean;
     block_unscanned: boolean;
+    max_artifact_age_days?: number | null;
     max_severity: string;
+    min_staging_hours?: number | null;
     name: string;
     repository_id?: string | null;
+    require_signature?: boolean;
 };
 
 export type CreateRepositoryRequest = {
@@ -538,6 +685,20 @@ export type CreateRepositoryRequest = {
     upstream_url?: string | null;
 };
 
+export type CreateRuleRequest = {
+    allowed_licenses?: Array<string> | null;
+    auto_promote?: boolean;
+    is_enabled?: boolean;
+    max_artifact_age_days?: number | null;
+    max_cve_severity?: string | null;
+    min_health_score?: number | null;
+    min_staging_hours?: number | null;
+    name: string;
+    require_signature?: boolean;
+    source_repo_id: string;
+    target_repo_id: string;
+};
+
 export type CreateSamlConfigRequest = {
     admin_group?: string | null;
     attribute_mapping?: {
@@ -555,6 +716,24 @@ export type CreateSamlConfigRequest = {
     sso_url: string;
 };
 
+export type CreateSyncPolicyPayload = {
+    artifact_filter?: {
+        [key: string]: unknown;
+    };
+    description?: string;
+    enabled?: boolean;
+    name: string;
+    peer_selector?: {
+        [key: string]: unknown;
+    };
+    precedence?: number;
+    priority?: number;
+    replication_mode?: string;
+    repo_selector?: {
+        [key: string]: unknown;
+    };
+};
+
 export type CreateTicketRequest = {
     purpose: string;
     resource_path?: string | null;
@@ -679,6 +858,16 @@ export type DateRangeQuery = {
     to?: string | null;
 };
 
+/**
+ * Database connection pool statistics.
+ */
+export type DbPoolStats = {
+    active_connections: number;
+    idle_connections: number;
+    max_connections: number;
+    size: number;
+};
+
 export type DeliveryListResponse = {
     items: Array<DeliveryResponse>;
     total: number;
@@ -942,6 +1131,13 @@ export type ErrorResponse = {
     message: string;
 };
 
+export type EvaluationResultResponse = {
+    created: number;
+    policies_evaluated: number;
+    removed: number;
+    updated: number;
+};
+
 export type EventsQuery = {
     limit?: number | null;
 };
@@ -1030,6 +1226,46 @@ export type FormatHandlerResponse = {
  */
 export type FormatHandlerType = 'Core' | 'Wasm';
 
+export type GateEvaluationResponse = {
+    action: string;
+    component_scores: {
+        [key: string]: unknown;
+    };
+    gate_name: string;
+    health_grade: string;
+    health_score: number;
+    passed: boolean;
+    violations: Array<GateViolationResponse>;
+};
+
+export type GateResponse = {
+    action: string;
+    created_at: string;
+    description?: string | null;
+    enforce_on_download: boolean;
+    enforce_on_promotion: boolean;
+    id: string;
+    is_enabled: boolean;
+    max_critical_issues?: number | null;
+    max_high_issues?: number | null;
+    max_medium_issues?: number | null;
+    min_health_score?: number | null;
+    min_metadata_score?: number | null;
+    min_quality_score?: number | null;
+    min_security_score?: number | null;
+    name: string;
+    repository_id?: string | null;
+    required_checks: Array<string>;
+    updated_at: string;
+};
+
+export type GateViolationResponse = {
+    actual: string;
+    expected: string;
+    message: string;
+    rule: string;
+};
+
 export type GenerateSbomRequest = {
     artifact_id: string;
     force_regenerate?: boolean;
@@ -1087,8 +1323,21 @@ export type HealthChecks = {
     storage: CheckStatus;
 };
 
+export type HealthDashboardResponse = {
+    avg_health_score: number;
+    repos_grade_a: number;
+    repos_grade_b: number;
+    repos_grade_c: number;
+    repos_grade_d: number;
+    repos_grade_f: number;
+    repositories: Array<RepoHealthResponse>;
+    total_artifacts_evaluated: number;
+    total_repositories: number;
+};
+
 export type HealthResponse = {
     checks: HealthChecks;
+    db_pool?: null | DbPoolStats;
     demo_mode: boolean;
     status: string;
     version: string;
@@ -1135,6 +1384,22 @@ export type InstallFromLocalRequest = {
     path: string;
 };
 
+export type IssueResponse = {
+    artifact_id: string;
+    category: string;
+    check_result_id: string;
+    created_at: string;
+    description?: string | null;
+    id: string;
+    is_suppressed: boolean;
+    location?: string | null;
+    severity: string;
+    suppressed_at?: string | null;
+    suppressed_by?: string | null;
+    suppressed_reason?: string | null;
+    title: string;
+};
+
 export type KeyListResponse = {
     keys: Array<SigningKeyPublic>;
     total: number;
@@ -1293,6 +1558,13 @@ export type ListUsersQuery = {
     search?: string | null;
 };
 
+/**
+ * Lightweight liveness response.
+ */
+export type LivezResponse = {
+    status: string;
+};
+
 export type LoginRequest = {
     password: string;
     username: string;
@@ -1308,6 +1580,18 @@ export type LoginResponse = {
     totp_token?: string | null;
 };
 
+export type MatchedPeerSchema = {
+    id: string;
+    name: string;
+    region?: string | null;
+};
+
+export type MatchedRepoSchema = {
+    format: string;
+    id: string;
+    key: string;
+};
+
 export type MembersRequest = {
     user_ids: Array<string>;
 };
@@ -1559,6 +1843,24 @@ export type PeerInstanceResponse = {
     status: string;
 };
 
+export type PeerLabelEntrySchema = {
+    key: string;
+    value?: string;
+};
+
+export type PeerLabelResponse = {
+    created_at: string;
+    id: string;
+    key: string;
+    peer_instance_id: string;
+    value: string;
+};
+
+export type PeerLabelsListResponse = {
+    items: Array<PeerLabelResponse>;
+    total: number;
+};
+
 export type PeerResponse = {
     bandwidth_estimate_bps?: number | null;
     bytes_transferred_total: number;
@@ -1574,6 +1876,21 @@ export type PeerResponse = {
     transfer_success_count: number;
 };
 
+export type PeerSelectorSchema = {
+    all?: boolean;
+    match_labels?: {
+        [key: string]: string;
+    };
+    match_peers?: Array<string>;
+    match_region?: string | null;
+};
+
+export type PendingQuery = {
+    page?: number | null;
+    per_page?: number | null;
+    source_repository?: string | null;
+};
+
 export type PermissionListResponse = {
     items: Array<PermissionResponse>;
     pagination: Pagination;
@@ -1676,9 +1993,12 @@ export type PolicyResponse = {
     created_at: string;
     id: string;
     is_enabled: boolean;
+    max_artifact_age_days?: number | null;
     max_severity: string;
+    min_staging_hours?: number | null;
     name: string;
     repository_id?: string | null;
+    require_signature: boolean;
     updated_at: string;
 };
 
@@ -1688,6 +2008,30 @@ export type PolicyViolation = {
     severity: string;
 };
 
+export type PreviewPolicyPayload = {
+    artifact_filter?: {
+        [key: string]: unknown;
+    };
+    description?: string;
+    enabled?: boolean;
+    name: string;
+    peer_selector?: {
+        [key: string]: unknown;
+    };
+    precedence?: number;
+    priority?: number;
+    replication_mode?: string;
+    repo_selector?: {
+        [key: string]: unknown;
+    };
+};
+
+export type PreviewResultResponse = {
+    matched_peers: Array<MatchedPeerSchema>;
+    matched_repositories: Array<MatchedRepoSchema>;
+    subscription_count: number;
+};
+
 export type ProbeBody = {
     bandwidth_estimate_bps?: number | null;
     latency_ms: number;
@@ -1711,7 +2055,9 @@ export type PromotionHistoryEntry = {
     } | null;
     promoted_by?: string | null;
     promoted_by_username?: string | null;
+    rejection_reason?: string | null;
     source_repo_key: string;
+    status: string;
     target_repo_key: string;
 };
 
@@ -1719,6 +2065,7 @@ export type PromotionHistoryQuery = {
     artifact_id?: string | null;
     page?: number | null;
     per_page?: number | null;
+    status?: string | null;
 };
 
 export type PromotionHistoryResponse = {
@@ -1735,10 +2082,46 @@ export type PromotionResponse = {
     target: string;
 };
 
+export type PromotionRuleListResponse = {
+    items: Array<PromotionRuleResponse>;
+    total: number;
+};
+
+export type PromotionRuleResponse = {
+    allowed_licenses?: Array<string> | null;
+    auto_promote: boolean;
+    created_at: string;
+    id: string;
+    is_enabled: boolean;
+    max_artifact_age_days?: number | null;
+    max_cve_severity?: string | null;
+    min_health_score?: number | null;
+    min_staging_hours?: number | null;
+    name: string;
+    require_signature: boolean;
+    source_repo_id: string;
+    target_repo_id: string;
+    updated_at: string;
+};
+
 export type QuickSearchResponse = {
     results: Array<SearchResultItem>;
 };
 
+export type ReadyzChecks = {
+    database: CheckStatus;
+    migrations: CheckStatus;
+    setup_complete: CheckStatus;
+};
+
+/**
+ * Readiness response with per-check detail.
+ */
+export type ReadyzResponse = {
+    checks: ReadyzChecks;
+    status: string;
+};
+
 export type RefreshTokenRequest = {
     refresh_token?: string | null;
 };
@@ -1760,6 +2143,19 @@ export type ReindexResponse = {
     repositories_indexed: number;
 };
 
+export type RejectArtifactRequest = {
+    notes?: string | null;
+    reason: string;
+};
+
+export type RejectionResponse = {
+    artifact_id: string;
+    reason: string;
+    rejected: boolean;
+    rejection_id: string;
+    source: string;
+};
+
 export type RemoteInstanceResponse = {
     created_at: string;
     id: string;
@@ -1767,11 +2163,35 @@ export type RemoteInstanceResponse = {
     url: string;
 };
 
+export type RepoHealthResponse = {
+    artifacts_evaluated: number;
+    artifacts_failing: number;
+    artifacts_passing: number;
+    avg_license_score?: number | null;
+    avg_metadata_score?: number | null;
+    avg_quality_score?: number | null;
+    avg_security_score?: number | null;
+    health_grade: string;
+    health_score: number;
+    last_evaluated_at?: string | null;
+    repository_id: string;
+    repository_key: string;
+};
+
 export type RepoSecurityResponse = {
     config?: null | ScanConfigResponse;
     score?: null | ScoreResponse;
 };
 
+export type RepoSelectorSchema = {
+    match_formats?: Array<string>;
+    match_labels?: {
+        [key: string]: string;
+    };
+    match_pattern?: string | null;
+    match_repos?: Array<string>;
+};
+
 export type RepositoryAssessment = {
     artifact_count: number;
     compatibility: string;
@@ -1861,6 +2281,13 @@ export type RestoreResponse = {
     tables_restored: Array<string>;
 };
 
+export type ReviewRequest = {
+    /**
+     * Optional reviewer notes
+     */
+    notes?: string | null;
+};
+
 export type RoleListResponse = {
     items: Array<RoleResponse>;
 };
@@ -1872,6 +2299,13 @@ export type RoleResponse = {
     permissions: Array<string>;
 };
 
+export type RuleEvaluationResponse = {
+    passed: boolean;
+    rule_id: string;
+    rule_name: string;
+    violations: Array<string>;
+};
+
 export type SamlAcsForm = {
     RelayState?: string | null;
     SAMLResponse: string;
@@ -2015,6 +2449,10 @@ export type SetLabelsRequest = {
     labels: Array<LabelEntrySchema>;
 };
 
+export type SetPeerLabelsRequest = {
+    labels: Array<PeerLabelEntrySchema>;
+};
+
 /**
  * Response body for the setup status endpoint.
  */
@@ -2125,11 +2563,41 @@ export type SuggestResponse = {
     suggestions: Array<string>;
 };
 
+export type SuppressIssueRequest = {
+    reason: string;
+};
+
 export type SuppressRequest = {
     service_name: string;
     until: string;
 };
 
+export type SyncPolicyListResponse = {
+    items: Array<SyncPolicyResponse>;
+    total: number;
+};
+
+export type SyncPolicyResponse = {
+    artifact_filter: {
+        [key: string]: unknown;
+    };
+    created_at: string;
+    description: string;
+    enabled: boolean;
+    id: string;
+    name: string;
+    peer_selector: {
+        [key: string]: unknown;
+    };
+    precedence: number;
+    priority: number;
+    replication_mode: string;
+    repo_selector: {
+        [key: string]: unknown;
+    };
+    updated_at: string;
+};
+
 export type SyncTaskResponse = {
     artifact_id: string;
     artifact_size: number;
@@ -2226,6 +2694,10 @@ export type TicketResponse = {
     ticket: string;
 };
 
+export type TogglePolicyPayload = {
+    enabled: boolean;
+};
+
 export type ToggleRequest = {
     enabled: boolean;
 };
@@ -2282,6 +2754,16 @@ export type TreeResponse = {
     nodes: Array<TreeNodeResponse>;
 };
 
+export type TriggerChecksRequest = {
+    artifact_id?: string | null;
+    repository_id?: string | null;
+};
+
+export type TriggerChecksResponse = {
+    artifacts_queued: number;
+    message: string;
+};
+
 export type TriggerScanRequest = {
     artifact_id?: string | null;
     repository_id?: string | null;
@@ -2324,10 +2806,27 @@ export type UpdateCveStatusRequest = {
     status: string;
 };
 
-export type UpdateLdapConfigRequest = {
-    admin_group_dn?: string | null;
-    bind_dn?: string | null;
-    bind_password?: string | null;
+export type UpdateGateRequest = {
+    action?: string | null;
+    description?: string | null;
+    enforce_on_download?: boolean | null;
+    enforce_on_promotion?: boolean | null;
+    is_enabled?: boolean | null;
+    max_critical_issues?: number | null;
+    max_high_issues?: number | null;
+    max_medium_issues?: number | null;
+    min_health_score?: number | null;
+    min_metadata_score?: number | null;
+    min_quality_score?: number | null;
+    min_security_score?: number | null;
+    name?: string | null;
+    required_checks?: Array<string> | null;
+};
+
+export type UpdateLdapConfigRequest = {
+    admin_group_dn?: string | null;
+    bind_dn?: string | null;
+    bind_password?: string | null;
     display_name_attribute?: string | null;
     email_attribute?: string | null;
     group_base_dn?: string | null;
@@ -2366,17 +2865,33 @@ export type UpdatePolicyRequest = {
     block_on_fail: boolean;
     block_unscanned: boolean;
     is_enabled: boolean;
+    max_artifact_age_days?: number | null;
     max_severity: string;
+    min_staging_hours?: number | null;
     name: string;
+    require_signature?: boolean;
 };
 
 export type UpdateRepositoryRequest = {
     description?: string | null;
     is_public?: boolean | null;
+    key?: string | null;
     name?: string | null;
     quota_bytes?: number | null;
 };
 
+export type UpdateRuleRequest = {
+    allowed_licenses?: Array<string> | null;
+    auto_promote?: boolean | null;
+    is_enabled?: boolean | null;
+    max_artifact_age_days?: number | null;
+    max_cve_severity?: string | null;
+    min_health_score?: number | null;
+    min_staging_hours?: number | null;
+    name?: string | null;
+    require_signature?: boolean | null;
+};
+
 export type UpdateSamlConfigRequest = {
     admin_group?: string | null;
     attribute_mapping?: {
@@ -2401,6 +2916,24 @@ export type UpdateSigningConfigPayload = {
     signing_key_id?: string | null;
 };
 
+export type UpdateSyncPolicyPayload = {
+    artifact_filter?: {
+        [key: string]: unknown;
+    };
+    description?: string | null;
+    enabled?: boolean | null;
+    name?: string | null;
+    peer_selector?: {
+        [key: string]: unknown;
+    };
+    precedence?: number | null;
+    priority?: number | null;
+    replication_mode?: string | null;
+    repo_selector?: {
+        [key: string]: unknown;
+    };
+};
+
 export type UpdateUserRequest = {
     display_name?: string | null;
     email?: string | null;
@@ -3937,6 +4470,207 @@ export type UpdateTelemetrySettingsResponses = {
 
 export type UpdateTelemetrySettingsResponse = UpdateTelemetrySettingsResponses[keyof UpdateTelemetrySettingsResponses];
 
+export type ListApprovalHistoryData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Page number (1-indexed)
+         */
+        page?: number;
+        /**
+         * Items per page (max 100)
+         */
+        per_page?: number;
+        /**
+         * Filter by status (pending, approved, rejected)
+         */
+        status?: string;
+        /**
+         * Filter by source repository key
+         */
+        source_repository?: string;
+    };
+    url: '/api/v1/approval/history';
+};
+
+export type ListApprovalHistoryResponses = {
+    /**
+     * Approval history
+     */
+    200: ApprovalListResponse;
+};
+
+export type ListApprovalHistoryResponse = ListApprovalHistoryResponses[keyof ListApprovalHistoryResponses];
+
+export type ListPendingApprovalsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Page number (1-indexed)
+         */
+        page?: number;
+        /**
+         * Items per page (max 100)
+         */
+        per_page?: number;
+        /**
+         * Filter by source repository key
+         */
+        source_repository?: string;
+    };
+    url: '/api/v1/approval/pending';
+};
+
+export type ListPendingApprovalsResponses = {
+    /**
+     * Pending approval requests
+     */
+    200: ApprovalListResponse;
+};
+
+export type ListPendingApprovalsResponse = ListPendingApprovalsResponses[keyof ListPendingApprovalsResponses];
+
+export type RequestApprovalData = {
+    body: ApprovalRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/approval/request';
+};
+
+export type RequestApprovalErrors = {
+    /**
+     * Artifact or repository not found
+     */
+    404: ErrorResponse;
+    /**
+     * Pending approval already exists
+     */
+    409: ErrorResponse;
+    /**
+     * Validation error
+     */
+    422: ErrorResponse;
+};
+
+export type RequestApprovalError = RequestApprovalErrors[keyof RequestApprovalErrors];
+
+export type RequestApprovalResponses = {
+    /**
+     * Approval request created
+     */
+    201: ApprovalResponse;
+};
+
+export type RequestApprovalResponse = RequestApprovalResponses[keyof RequestApprovalResponses];
+
+export type GetApprovalData = {
+    body?: never;
+    path: {
+        /**
+         * Approval request ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/approval/{id}';
+};
+
+export type GetApprovalErrors = {
+    /**
+     * Approval request not found
+     */
+    404: ErrorResponse;
+};
+
+export type GetApprovalError = GetApprovalErrors[keyof GetApprovalErrors];
+
+export type GetApprovalResponses = {
+    /**
+     * Approval request details
+     */
+    200: ApprovalResponse;
+};
+
+export type GetApprovalResponse = GetApprovalResponses[keyof GetApprovalResponses];
+
+export type ApprovePromotionData = {
+    body: ReviewRequest;
+    path: {
+        /**
+         * Approval request ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/approval/{id}/approve';
+};
+
+export type ApprovePromotionErrors = {
+    /**
+     * Admin access required
+     */
+    403: ErrorResponse;
+    /**
+     * Approval request not found
+     */
+    404: ErrorResponse;
+    /**
+     * Approval already reviewed
+     */
+    409: ErrorResponse;
+};
+
+export type ApprovePromotionError = ApprovePromotionErrors[keyof ApprovePromotionErrors];
+
+export type ApprovePromotionResponses = {
+    /**
+     * Promotion approved and executed
+     */
+    200: ApprovalResponse;
+};
+
+export type ApprovePromotionResponse = ApprovePromotionResponses[keyof ApprovePromotionResponses];
+
+export type RejectPromotionData = {
+    body: ReviewRequest;
+    path: {
+        /**
+         * Approval request ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/approval/{id}/reject';
+};
+
+export type RejectPromotionErrors = {
+    /**
+     * Admin access required
+     */
+    403: ErrorResponse;
+    /**
+     * Approval request not found
+     */
+    404: ErrorResponse;
+    /**
+     * Approval already reviewed
+     */
+    409: ErrorResponse;
+};
+
+export type RejectPromotionError = RejectPromotionErrors[keyof RejectPromotionErrors];
+
+export type RejectPromotionResponses = {
+    /**
+     * Promotion rejected
+     */
+    200: ApprovalResponse;
+};
+
+export type RejectPromotionResponse = RejectPromotionResponses[keyof RejectPromotionResponses];
+
 export type GetArtifactData = {
     body?: never;
     path: {
@@ -6358,8 +7092,8 @@ export type HeartbeatResponses = {
     200: unknown;
 };
 
-export type UpdateNetworkProfileData = {
-    body: NetworkProfileBody;
+export type ListLabelsData = {
+    body?: never;
     path: {
         /**
          * Peer instance ID
@@ -6367,18 +7101,27 @@ export type UpdateNetworkProfileData = {
         id: string;
     };
     query?: never;
-    url: '/api/v1/peers/{id}/network-profile';
+    url: '/api/v1/peers/{id}/labels';
 };
 
-export type UpdateNetworkProfileResponses = {
+export type ListLabelsErrors = {
     /**
-     * Network profile updated
+     * Peer instance not found
      */
-    200: unknown;
+    404: unknown;
 };
 
-export type GetAssignedReposData = {
-    body?: never;
+export type ListLabelsResponses = {
+    /**
+     * Labels retrieved
+     */
+    200: PeerLabelsListResponse;
+};
+
+export type ListLabelsResponse = ListLabelsResponses[keyof ListLabelsResponses];
+
+export type SetLabelsData = {
+    body: SetPeerLabelsRequest;
     path: {
         /**
          * Peer instance ID
@@ -6386,95 +7129,91 @@ export type GetAssignedReposData = {
         id: string;
     };
     query?: never;
-    url: '/api/v1/peers/{id}/repositories';
+    url: '/api/v1/peers/{id}/labels';
 };
 
-export type GetAssignedReposErrors = {
+export type SetLabelsErrors = {
     /**
      * Peer instance not found
      */
     404: unknown;
-    /**
-     * Internal server error
-     */
-    500: unknown;
 };
 
-export type GetAssignedReposResponses = {
+export type SetLabelsResponses = {
     /**
-     * List of assigned repository IDs
+     * Labels updated
      */
-    200: Array<string>;
+    200: PeerLabelsListResponse;
 };
 
-export type GetAssignedReposResponse = GetAssignedReposResponses[keyof GetAssignedReposResponses];
+export type SetLabelsResponse = SetLabelsResponses[keyof SetLabelsResponses];
 
-export type AssignRepoData = {
-    body: AssignRepoRequest;
+export type DeleteLabelData = {
+    body?: never;
     path: {
         /**
          * Peer instance ID
          */
         id: string;
+        /**
+         * Label key to remove
+         */
+        label_key: string;
     };
     query?: never;
-    url: '/api/v1/peers/{id}/repositories';
+    url: '/api/v1/peers/{id}/labels/{label_key}';
 };
 
-export type AssignRepoErrors = {
+export type DeleteLabelErrors = {
     /**
-     * Peer instance not found
+     * Peer instance or label not found
      */
     404: unknown;
-    /**
-     * Internal server error
-     */
-    500: unknown;
 };
 
-export type AssignRepoResponses = {
+export type DeleteLabelResponses = {
     /**
-     * Repository assigned successfully
+     * Label removed
      */
-    200: unknown;
+    204: void;
 };
 
-export type UnassignRepoData = {
-    body?: never;
+export type DeleteLabelResponse = DeleteLabelResponses[keyof DeleteLabelResponses];
+
+export type AddLabelData = {
+    body: AddPeerLabelRequest;
     path: {
         /**
          * Peer instance ID
          */
         id: string;
         /**
-         * Repository ID
+         * Label key to set
          */
-        repo_id: string;
+        label_key: string;
     };
     query?: never;
-    url: '/api/v1/peers/{id}/repositories/{repo_id}';
+    url: '/api/v1/peers/{id}/labels/{label_key}';
 };
 
-export type UnassignRepoErrors = {
+export type AddLabelErrors = {
     /**
-     * Peer instance or repository not found
+     * Peer instance not found
      */
     404: unknown;
-    /**
-     * Internal server error
-     */
-    500: unknown;
 };
 
-export type UnassignRepoResponses = {
+export type AddLabelResponses = {
     /**
-     * Repository unassigned successfully
+     * Label added/updated
      */
-    200: unknown;
+    200: PeerLabelResponse;
 };
 
-export type TriggerSyncData = {
-    body?: never;
+export type AddLabelResponse = AddLabelResponses[keyof AddLabelResponses];
+
+export type UpdateNetworkProfileData = {
+    body: NetworkProfileBody;
     path: {
         /**
          * Peer instance ID
@@ -6482,14 +7221,129 @@ export type TriggerSyncData = {
         id: string;
     };
     query?: never;
-    url: '/api/v1/peers/{id}/sync';
+    url: '/api/v1/peers/{id}/network-profile';
 };
 
-export type TriggerSyncErrors = {
+export type UpdateNetworkProfileResponses = {
     /**
-     * Peer instance not found
+     * Network profile updated
      */
-    404: unknown;
+    200: unknown;
+};
+
+export type GetAssignedReposData = {
+    body?: never;
+    path: {
+        /**
+         * Peer instance ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/peers/{id}/repositories';
+};
+
+export type GetAssignedReposErrors = {
+    /**
+     * Peer instance not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type GetAssignedReposResponses = {
+    /**
+     * List of assigned repository IDs
+     */
+    200: Array<string>;
+};
+
+export type GetAssignedReposResponse = GetAssignedReposResponses[keyof GetAssignedReposResponses];
+
+export type AssignRepoData = {
+    body: AssignRepoRequest;
+    path: {
+        /**
+         * Peer instance ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/peers/{id}/repositories';
+};
+
+export type AssignRepoErrors = {
+    /**
+     * Peer instance not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type AssignRepoResponses = {
+    /**
+     * Repository assigned successfully
+     */
+    200: unknown;
+};
+
+export type UnassignRepoData = {
+    body?: never;
+    path: {
+        /**
+         * Peer instance ID
+         */
+        id: string;
+        /**
+         * Repository ID
+         */
+        repo_id: string;
+    };
+    query?: never;
+    url: '/api/v1/peers/{id}/repositories/{repo_id}';
+};
+
+export type UnassignRepoErrors = {
+    /**
+     * Peer instance or repository not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type UnassignRepoResponses = {
+    /**
+     * Repository unassigned successfully
+     */
+    200: unknown;
+};
+
+export type TriggerSyncData = {
+    body?: never;
+    path: {
+        /**
+         * Peer instance ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/peers/{id}/sync';
+};
+
+export type TriggerSyncErrors = {
+    /**
+     * Peer instance not found
+     */
+    404: unknown;
     /**
      * Internal server error
      */
@@ -7209,6 +8063,178 @@ export type ReloadPluginResponses = {
 
 export type ReloadPluginResponse = ReloadPluginResponses[keyof ReloadPluginResponses];
 
+export type ListRulesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        source_repo_id?: string | null;
+    };
+    url: '/api/v1/promotion-rules';
+};
+
+export type ListRulesErrors = {
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type ListRulesResponses = {
+    /**
+     * List of promotion rules
+     */
+    200: PromotionRuleListResponse;
+};
+
+export type ListRulesResponse = ListRulesResponses[keyof ListRulesResponses];
+
+export type CreateRuleData = {
+    body: CreateRuleRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/promotion-rules';
+};
+
+export type CreateRuleErrors = {
+    /**
+     * Validation error
+     */
+    400: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type CreateRuleError = CreateRuleErrors[keyof CreateRuleErrors];
+
+export type CreateRuleResponses = {
+    /**
+     * Promotion rule created
+     */
+    200: PromotionRuleResponse;
+};
+
+export type CreateRuleResponse = CreateRuleResponses[keyof CreateRuleResponses];
+
+export type DeleteRuleData = {
+    body?: never;
+    path: {
+        /**
+         * Promotion rule ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/promotion-rules/{id}';
+};
+
+export type DeleteRuleErrors = {
+    /**
+     * Rule not found
+     */
+    404: ErrorResponse;
+};
+
+export type DeleteRuleError = DeleteRuleErrors[keyof DeleteRuleErrors];
+
+export type DeleteRuleResponses = {
+    /**
+     * Promotion rule deleted
+     */
+    200: unknown;
+};
+
+export type GetRuleData = {
+    body?: never;
+    path: {
+        /**
+         * Promotion rule ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/promotion-rules/{id}';
+};
+
+export type GetRuleErrors = {
+    /**
+     * Rule not found
+     */
+    404: ErrorResponse;
+};
+
+export type GetRuleError = GetRuleErrors[keyof GetRuleErrors];
+
+export type GetRuleResponses = {
+    /**
+     * Promotion rule details
+     */
+    200: PromotionRuleResponse;
+};
+
+export type GetRuleResponse = GetRuleResponses[keyof GetRuleResponses];
+
+export type UpdateRuleData = {
+    body: UpdateRuleRequest;
+    path: {
+        /**
+         * Promotion rule ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/promotion-rules/{id}';
+};
+
+export type UpdateRuleErrors = {
+    /**
+     * Rule not found
+     */
+    404: ErrorResponse;
+};
+
+export type UpdateRuleError = UpdateRuleErrors[keyof UpdateRuleErrors];
+
+export type UpdateRuleResponses = {
+    /**
+     * Promotion rule updated
+     */
+    200: PromotionRuleResponse;
+};
+
+export type UpdateRuleResponse = UpdateRuleResponses[keyof UpdateRuleResponses];
+
+export type EvaluateRuleData = {
+    body?: never;
+    path: {
+        /**
+         * Promotion rule ID to evaluate
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/promotion-rules/{id}/evaluate';
+};
+
+export type EvaluateRuleErrors = {
+    /**
+     * Rule not found
+     */
+    404: ErrorResponse;
+};
+
+export type EvaluateRuleError = EvaluateRuleErrors[keyof EvaluateRuleErrors];
+
+export type EvaluateRuleResponses = {
+    /**
+     * Evaluation results
+     */
+    200: BulkEvaluationResponse;
+};
+
+export type EvaluateRuleResponse = EvaluateRuleResponses[keyof EvaluateRuleResponses];
+
 export type PromoteArtifactData = {
     body: PromoteArtifactRequest;
     path: {
@@ -7242,91 +8268,538 @@ export type PromoteArtifactErrors = {
 
 export type PromoteArtifactError = PromoteArtifactErrors[keyof PromoteArtifactErrors];
 
-export type PromoteArtifactResponses = {
+export type PromoteArtifactResponses = {
+    /**
+     * Artifact promotion result
+     */
+    200: PromotionResponse;
+};
+
+export type PromoteArtifactResponse = PromoteArtifactResponses[keyof PromoteArtifactResponses];
+
+export type RejectArtifactData = {
+    body: RejectArtifactRequest;
+    path: {
+        /**
+         * Source repository key
+         */
+        key: string;
+        /**
+         * Artifact ID to reject
+         */
+        artifact_id: string;
+    };
+    query?: never;
+    url: '/api/v1/promotion/repositories/{key}/artifacts/{artifact_id}/reject';
+};
+
+export type RejectArtifactErrors = {
+    /**
+     * Artifact or repository not found
+     */
+    404: ErrorResponse;
+    /**
+     * Validation error
+     */
+    422: ErrorResponse;
+};
+
+export type RejectArtifactError = RejectArtifactErrors[keyof RejectArtifactErrors];
+
+export type RejectArtifactResponses = {
+    /**
+     * Artifact rejection result
+     */
+    200: RejectionResponse;
+};
+
+export type RejectArtifactResponse = RejectArtifactResponses[keyof RejectArtifactResponses];
+
+export type PromoteArtifactsBulkData = {
+    body: BulkPromoteRequest;
+    path: {
+        /**
+         * Source repository key
+         */
+        key: string;
+    };
+    query?: never;
+    url: '/api/v1/promotion/repositories/{key}/promote';
+};
+
+export type PromoteArtifactsBulkErrors = {
+    /**
+     * Repository not found
+     */
+    404: ErrorResponse;
+    /**
+     * Validation error (repo type/format mismatch)
+     */
+    422: ErrorResponse;
+};
+
+export type PromoteArtifactsBulkError = PromoteArtifactsBulkErrors[keyof PromoteArtifactsBulkErrors];
+
+export type PromoteArtifactsBulkResponses = {
+    /**
+     * Bulk promotion results
+     */
+    200: BulkPromotionResponse;
+};
+
+export type PromoteArtifactsBulkResponse = PromoteArtifactsBulkResponses[keyof PromoteArtifactsBulkResponses];
+
+export type PromotionHistoryData = {
+    body?: never;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+    };
+    query?: {
+        /**
+         * Page number (1-indexed)
+         */
+        page?: number;
+        /**
+         * Items per page (max 100)
+         */
+        per_page?: number;
+        /**
+         * Filter by artifact ID
+         */
+        artifact_id?: string;
+        /**
+         * Filter by status (promoted, rejected, pending_approval)
+         */
+        status?: string;
+    };
+    url: '/api/v1/promotion/repositories/{key}/promotion-history';
+};
+
+export type PromotionHistoryErrors = {
+    /**
+     * Repository not found
+     */
+    404: ErrorResponse;
+};
+
+export type PromotionHistoryError = PromotionHistoryErrors[keyof PromotionHistoryErrors];
+
+export type PromotionHistoryResponses = {
+    /**
+     * Promotion history for repository
+     */
+    200: PromotionHistoryResponse;
+};
+
+export type PromotionHistoryResponse2 = PromotionHistoryResponses[keyof PromotionHistoryResponses];
+
+export type ListChecksData = {
+    body?: never;
+    path?: never;
+    query?: {
+        artifact_id?: string | null;
+        repository_id?: string | null;
+    };
+    url: '/api/v1/quality/checks';
+};
+
+export type ListChecksResponses = {
+    /**
+     * List of quality check results
+     */
+    200: Array<CheckResponse>;
+};
+
+export type ListChecksResponse = ListChecksResponses[keyof ListChecksResponses];
+
+export type TriggerChecksData = {
+    body: TriggerChecksRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/quality/checks/trigger';
+};
+
+export type TriggerChecksErrors = {
+    /**
+     * Validation error
+     */
+    400: ErrorResponse;
+};
+
+export type TriggerChecksError = TriggerChecksErrors[keyof TriggerChecksErrors];
+
+export type TriggerChecksResponses = {
+    /**
+     * Quality checks triggered
+     */
+    200: TriggerChecksResponse;
+};
+
+export type TriggerChecksResponse2 = TriggerChecksResponses[keyof TriggerChecksResponses];
+
+export type GetCheckData = {
+    body?: never;
+    path: {
+        /**
+         * Check result ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/quality/checks/{id}';
+};
+
+export type GetCheckErrors = {
+    /**
+     * Check result not found
+     */
+    404: ErrorResponse;
+};
+
+export type GetCheckError = GetCheckErrors[keyof GetCheckErrors];
+
+export type GetCheckResponses = {
+    /**
+     * Check result details
+     */
+    200: CheckResponse;
+};
+
+export type GetCheckResponse = GetCheckResponses[keyof GetCheckResponses];
+
+export type ListCheckIssuesData = {
+    body?: never;
+    path: {
+        /**
+         * Check result ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/quality/checks/{id}/issues';
+};
+
+export type ListCheckIssuesErrors = {
+    /**
+     * Check result not found
+     */
+    404: ErrorResponse;
+};
+
+export type ListCheckIssuesError = ListCheckIssuesErrors[keyof ListCheckIssuesErrors];
+
+export type ListCheckIssuesResponses = {
+    /**
+     * List of issues for a check result
+     */
+    200: Array<IssueResponse>;
+};
+
+export type ListCheckIssuesResponse = ListCheckIssuesResponses[keyof ListCheckIssuesResponses];
+
+export type ListGatesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/quality/gates';
+};
+
+export type ListGatesResponses = {
+    /**
+     * List of quality gates
+     */
+    200: Array<GateResponse>;
+};
+
+export type ListGatesResponse = ListGatesResponses[keyof ListGatesResponses];
+
+export type CreateGateData = {
+    body: CreateGateRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/quality/gates';
+};
+
+export type CreateGateErrors = {
+    /**
+     * Validation error
+     */
+    422: ErrorResponse;
+};
+
+export type CreateGateError = CreateGateErrors[keyof CreateGateErrors];
+
+export type CreateGateResponses = {
+    /**
+     * Quality gate created
+     */
+    200: GateResponse;
+};
+
+export type CreateGateResponse = CreateGateResponses[keyof CreateGateResponses];
+
+export type EvaluateGateData = {
+    body?: never;
+    path: {
+        /**
+         * Artifact ID to evaluate
+         */
+        artifact_id: string;
+    };
+    query?: {
+        repository_id?: string | null;
+    };
+    url: '/api/v1/quality/gates/evaluate/{artifact_id}';
+};
+
+export type EvaluateGateErrors = {
+    /**
+     * Artifact or gate not found
+     */
+    404: ErrorResponse;
+};
+
+export type EvaluateGateError = EvaluateGateErrors[keyof EvaluateGateErrors];
+
+export type EvaluateGateResponses = {
+    /**
+     * Gate evaluation result
+     */
+    200: GateEvaluationResponse;
+};
+
+export type EvaluateGateResponse = EvaluateGateResponses[keyof EvaluateGateResponses];
+
+export type DeleteGateData = {
+    body?: never;
+    path: {
+        /**
+         * Quality gate ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/quality/gates/{id}';
+};
+
+export type DeleteGateErrors = {
+    /**
+     * Quality gate not found
+     */
+    404: ErrorResponse;
+};
+
+export type DeleteGateError = DeleteGateErrors[keyof DeleteGateErrors];
+
+export type DeleteGateResponses = {
+    /**
+     * Quality gate deleted
+     */
+    200: {
+        [key: string]: unknown;
+    };
+};
+
+export type DeleteGateResponse = DeleteGateResponses[keyof DeleteGateResponses];
+
+export type GetGateData = {
+    body?: never;
+    path: {
+        /**
+         * Quality gate ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/quality/gates/{id}';
+};
+
+export type GetGateErrors = {
+    /**
+     * Quality gate not found
+     */
+    404: ErrorResponse;
+};
+
+export type GetGateError = GetGateErrors[keyof GetGateErrors];
+
+export type GetGateResponses = {
+    /**
+     * Quality gate details
+     */
+    200: GateResponse;
+};
+
+export type GetGateResponse = GetGateResponses[keyof GetGateResponses];
+
+export type UpdateGateData = {
+    body: UpdateGateRequest;
+    path: {
+        /**
+         * Quality gate ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/quality/gates/{id}';
+};
+
+export type UpdateGateErrors = {
+    /**
+     * Quality gate not found
+     */
+    404: ErrorResponse;
+};
+
+export type UpdateGateError = UpdateGateErrors[keyof UpdateGateErrors];
+
+export type UpdateGateResponses = {
+    /**
+     * Quality gate updated
+     */
+    200: GateResponse;
+};
+
+export type UpdateGateResponse = UpdateGateResponses[keyof UpdateGateResponses];
+
+export type GetArtifactHealthData = {
+    body?: never;
+    path: {
+        /**
+         * Artifact ID
+         */
+        artifact_id: string;
+    };
+    query?: never;
+    url: '/api/v1/quality/health/artifacts/{artifact_id}';
+};
+
+export type GetArtifactHealthErrors = {
+    /**
+     * Artifact not found
+     */
+    404: ErrorResponse;
+};
+
+export type GetArtifactHealthError = GetArtifactHealthErrors[keyof GetArtifactHealthErrors];
+
+export type GetArtifactHealthResponses = {
+    /**
+     * Artifact health score
+     */
+    200: ArtifactHealthResponse;
+};
+
+export type GetArtifactHealthResponse = GetArtifactHealthResponses[keyof GetArtifactHealthResponses];
+
+export type GetHealthDashboardData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/quality/health/dashboard';
+};
+
+export type GetHealthDashboardResponses = {
     /**
-     * Artifact promotion result
+     * Health dashboard summary
      */
-    200: PromotionResponse;
+    200: HealthDashboardResponse;
 };
 
-export type PromoteArtifactResponse = PromoteArtifactResponses[keyof PromoteArtifactResponses];
+export type GetHealthDashboardResponse = GetHealthDashboardResponses[keyof GetHealthDashboardResponses];
 
-export type PromoteArtifactsBulkData = {
-    body: BulkPromoteRequest;
+export type GetRepoHealthData = {
+    body?: never;
     path: {
         /**
-         * Source repository key
+         * Repository key
          */
         key: string;
     };
     query?: never;
-    url: '/api/v1/promotion/repositories/{key}/promote';
+    url: '/api/v1/quality/health/repositories/{key}';
 };
 
-export type PromoteArtifactsBulkErrors = {
+export type GetRepoHealthErrors = {
     /**
      * Repository not found
      */
     404: ErrorResponse;
-    /**
-     * Validation error (repo type/format mismatch)
-     */
-    422: ErrorResponse;
 };
 
-export type PromoteArtifactsBulkError = PromoteArtifactsBulkErrors[keyof PromoteArtifactsBulkErrors];
+export type GetRepoHealthError = GetRepoHealthErrors[keyof GetRepoHealthErrors];
 
-export type PromoteArtifactsBulkResponses = {
+export type GetRepoHealthResponses = {
     /**
-     * Bulk promotion results
+     * Repository health score
      */
-    200: BulkPromotionResponse;
+    200: RepoHealthResponse;
 };
 
-export type PromoteArtifactsBulkResponse = PromoteArtifactsBulkResponses[keyof PromoteArtifactsBulkResponses];
+export type GetRepoHealthResponse = GetRepoHealthResponses[keyof GetRepoHealthResponses];
 
-export type PromotionHistoryData = {
+export type UnsuppressIssueData = {
     body?: never;
     path: {
         /**
-         * Repository key
+         * Issue ID
          */
-        key: string;
+        id: string;
     };
-    query?: {
-        /**
-         * Page number (1-indexed)
-         */
-        page?: number;
-        /**
-         * Items per page (max 100)
-         */
-        per_page?: number;
+    query?: never;
+    url: '/api/v1/quality/issues/{id}/suppress';
+};
+
+export type UnsuppressIssueErrors = {
+    /**
+     * Issue not found
+     */
+    404: ErrorResponse;
+};
+
+export type UnsuppressIssueError = UnsuppressIssueErrors[keyof UnsuppressIssueErrors];
+
+export type UnsuppressIssueResponses = {
+    /**
+     * Issue unsuppressed
+     */
+    200: IssueResponse;
+};
+
+export type UnsuppressIssueResponse = UnsuppressIssueResponses[keyof UnsuppressIssueResponses];
+
+export type SuppressIssueData = {
+    body: SuppressIssueRequest;
+    path: {
         /**
-         * Filter by artifact ID
+         * Issue ID
          */
-        artifact_id?: string;
+        id: string;
     };
-    url: '/api/v1/promotion/repositories/{key}/promotion-history';
+    query?: never;
+    url: '/api/v1/quality/issues/{id}/suppress';
 };
 
-export type PromotionHistoryErrors = {
+export type SuppressIssueErrors = {
     /**
-     * Repository not found
+     * Issue not found
      */
     404: ErrorResponse;
 };
 
-export type PromotionHistoryError = PromotionHistoryErrors[keyof PromotionHistoryErrors];
+export type SuppressIssueError = SuppressIssueErrors[keyof SuppressIssueErrors];
 
-export type PromotionHistoryResponses = {
+export type SuppressIssueResponses = {
     /**
-     * Promotion history for repository
+     * Issue suppressed
      */
-    200: PromotionHistoryResponse;
+    200: IssueResponse;
 };
 
-export type PromotionHistoryResponse2 = PromotionHistoryResponses[keyof PromotionHistoryResponses];
+export type SuppressIssueResponse = SuppressIssueResponses[keyof SuppressIssueResponses];
 
 export type ListRepositoriesData = {
     body?: never;
@@ -7456,6 +8929,10 @@ export type UpdateRepositoryErrors = {
      * Repository not found
      */
     404: unknown;
+    /**
+     * Repository key already exists
+     */
+    409: unknown;
 };
 
 export type UpdateRepositoryResponses = {
@@ -7634,7 +9111,7 @@ export type DownloadArtifactResponses = {
 
 export type DownloadArtifactResponse = DownloadArtifactResponses[keyof DownloadArtifactResponses];
 
-export type ListLabelsData = {
+export type ListRepoLabelsData = {
     body?: never;
     path: {
         /**
@@ -7646,23 +9123,23 @@ export type ListLabelsData = {
     url: '/api/v1/repositories/{key}/labels';
 };
 
-export type ListLabelsErrors = {
+export type ListRepoLabelsErrors = {
     /**
      * Repository not found
      */
     404: unknown;
 };
 
-export type ListLabelsResponses = {
+export type ListRepoLabelsResponses = {
     /**
      * Labels retrieved
      */
     200: LabelsListResponse;
 };
 
-export type ListLabelsResponse = ListLabelsResponses[keyof ListLabelsResponses];
+export type ListRepoLabelsResponse = ListRepoLabelsResponses[keyof ListRepoLabelsResponses];
 
-export type SetLabelsData = {
+export type SetRepoLabelsData = {
     body: SetLabelsRequest;
     path: {
         /**
@@ -7674,23 +9151,23 @@ export type SetLabelsData = {
     url: '/api/v1/repositories/{key}/labels';
 };
 
-export type SetLabelsErrors = {
+export type SetRepoLabelsErrors = {
     /**
      * Repository not found
      */
     404: unknown;
 };
 
-export type SetLabelsResponses = {
+export type SetRepoLabelsResponses = {
     /**
      * Labels updated
      */
     200: LabelsListResponse;
 };
 
-export type SetLabelsResponse = SetLabelsResponses[keyof SetLabelsResponses];
+export type SetRepoLabelsResponse = SetRepoLabelsResponses[keyof SetRepoLabelsResponses];
 
-export type DeleteLabelData = {
+export type DeleteRepoLabelData = {
     body?: never;
     path: {
         /**
@@ -7706,23 +9183,23 @@ export type DeleteLabelData = {
     url: '/api/v1/repositories/{key}/labels/{label_key}';
 };
 
-export type DeleteLabelErrors = {
+export type DeleteRepoLabelErrors = {
     /**
      * Repository or label not found
      */
     404: unknown;
 };
 
-export type DeleteLabelResponses = {
+export type DeleteRepoLabelResponses = {
     /**
      * Label removed
      */
     204: void;
 };
 
-export type DeleteLabelResponse = DeleteLabelResponses[keyof DeleteLabelResponses];
+export type DeleteRepoLabelResponse = DeleteRepoLabelResponses[keyof DeleteRepoLabelResponses];
 
-export type AddLabelData = {
+export type AddRepoLabelData = {
     body: AddLabelRequest;
     path: {
         /**
@@ -7738,21 +9215,21 @@ export type AddLabelData = {
     url: '/api/v1/repositories/{key}/labels/{label_key}';
 };
 
-export type AddLabelErrors = {
+export type AddRepoLabelErrors = {
     /**
      * Repository not found
      */
     404: unknown;
 };
 
-export type AddLabelResponses = {
+export type AddRepoLabelResponses = {
     /**
      * Label added/updated
      */
     200: LabelResponse;
 };
 
-export type AddLabelResponse = AddLabelResponses[keyof AddLabelResponses];
+export type AddRepoLabelResponse = AddRepoLabelResponses[keyof AddRepoLabelResponses];
 
 export type ListVirtualMembersData = {
     body?: never;
@@ -9252,6 +10729,238 @@ export type GetRepoPublicKeyResponses = {
 
 export type GetRepoPublicKeyResponse = GetRepoPublicKeyResponses[keyof GetRepoPublicKeyResponses];
 
+export type ListSyncPoliciesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/sync-policies';
+};
+
+export type ListSyncPoliciesErrors = {
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type ListSyncPoliciesResponses = {
+    /**
+     * List of sync policies
+     */
+    200: SyncPolicyListResponse;
+};
+
+export type ListSyncPoliciesResponse = ListSyncPoliciesResponses[keyof ListSyncPoliciesResponses];
+
+export type CreateSyncPolicyData = {
+    body: CreateSyncPolicyPayload;
+    path?: never;
+    query?: never;
+    url: '/api/v1/sync-policies';
+};
+
+export type CreateSyncPolicyErrors = {
+    /**
+     * Validation error
+     */
+    400: unknown;
+    /**
+     * Policy name already exists
+     */
+    409: unknown;
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type CreateSyncPolicyResponses = {
+    /**
+     * Sync policy created
+     */
+    200: SyncPolicyResponse;
+};
+
+export type CreateSyncPolicyResponse = CreateSyncPolicyResponses[keyof CreateSyncPolicyResponses];
+
+export type EvaluatePoliciesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/sync-policies/evaluate';
+};
+
+export type EvaluatePoliciesErrors = {
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type EvaluatePoliciesResponses = {
+    /**
+     * Evaluation completed
+     */
+    200: EvaluationResultResponse;
+};
+
+export type EvaluatePoliciesResponse = EvaluatePoliciesResponses[keyof EvaluatePoliciesResponses];
+
+export type PreviewSyncPolicyData = {
+    body: PreviewPolicyPayload;
+    path?: never;
+    query?: never;
+    url: '/api/v1/sync-policies/preview';
+};
+
+export type PreviewSyncPolicyErrors = {
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type PreviewSyncPolicyResponses = {
+    /**
+     * Preview result
+     */
+    200: PreviewResultResponse;
+};
+
+export type PreviewSyncPolicyResponse = PreviewSyncPolicyResponses[keyof PreviewSyncPolicyResponses];
+
+export type DeleteSyncPolicyData = {
+    body?: never;
+    path: {
+        /**
+         * Sync policy ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/sync-policies/{id}';
+};
+
+export type DeleteSyncPolicyErrors = {
+    /**
+     * Sync policy not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type DeleteSyncPolicyResponses = {
+    /**
+     * Sync policy deleted
+     */
+    204: void;
+};
+
+export type DeleteSyncPolicyResponse = DeleteSyncPolicyResponses[keyof DeleteSyncPolicyResponses];
+
+export type GetSyncPolicyData = {
+    body?: never;
+    path: {
+        /**
+         * Sync policy ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/sync-policies/{id}';
+};
+
+export type GetSyncPolicyErrors = {
+    /**
+     * Sync policy not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type GetSyncPolicyResponses = {
+    /**
+     * Sync policy details
+     */
+    200: SyncPolicyResponse;
+};
+
+export type GetSyncPolicyResponse = GetSyncPolicyResponses[keyof GetSyncPolicyResponses];
+
+export type UpdateSyncPolicyData = {
+    body: UpdateSyncPolicyPayload;
+    path: {
+        /**
+         * Sync policy ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/sync-policies/{id}';
+};
+
+export type UpdateSyncPolicyErrors = {
+    /**
+     * Sync policy not found
+     */
+    404: unknown;
+    /**
+     * Policy name already exists
+     */
+    409: unknown;
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type UpdateSyncPolicyResponses = {
+    /**
+     * Sync policy updated
+     */
+    200: SyncPolicyResponse;
+};
+
+export type UpdateSyncPolicyResponse = UpdateSyncPolicyResponses[keyof UpdateSyncPolicyResponses];
+
+export type TogglePolicyData = {
+    body: TogglePolicyPayload;
+    path: {
+        /**
+         * Sync policy ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/sync-policies/{id}/toggle';
+};
+
+export type TogglePolicyErrors = {
+    /**
+     * Sync policy not found
+     */
+    404: unknown;
+    /**
+     * Internal server error
+     */
+    500: unknown;
+};
+
+export type TogglePolicyResponses = {
+    /**
+     * Sync policy toggled
+     */
+    200: SyncPolicyResponse;
+};
+
+export type TogglePolicyResponse = TogglePolicyResponses[keyof TogglePolicyResponses];
+
 export type GetTreeData = {
     body?: never;
     path?: never;
@@ -9937,23 +11646,43 @@ export type HealthCheckResponses = {
 
 export type HealthCheckResponse = HealthCheckResponses[keyof HealthCheckResponses];
 
+export type LivenessCheckData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/livez';
+};
+
+export type LivenessCheckResponses = {
+    /**
+     * Process is alive
+     */
+    200: LivezResponse;
+};
+
+export type LivenessCheckResponse = LivenessCheckResponses[keyof LivenessCheckResponses];
+
 export type ReadinessCheckData = {
     body?: never;
     path?: never;
     query?: never;
-    url: '/ready';
+    url: '/readyz';
 };
 
 export type ReadinessCheckErrors = {
     /**
      * Service is not ready
      */
-    503: unknown;
+    503: ReadyzResponse;
 };
 
+export type ReadinessCheckError = ReadinessCheckErrors[keyof ReadinessCheckErrors];
+
 export type ReadinessCheckResponses = {
     /**
-     * Service is ready to accept traffic
+     * Service is ready
      */
-    200: unknown;
+    200: ReadyzResponse;
 };
+
+export type ReadinessCheckResponse = ReadinessCheckResponses[keyof ReadinessCheckResponses];