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

package/src/types.gen.ts

@@ -16,6 +16,14 @@ export type AddBuildArtifactsResponse = {
     artifacts: Array<BuildArtifactResponse>;
 };
 
+export type AddLabelRequest = {
+    value?: string;
+};
+
+export type AddPeerLabelRequest = {
+    value?: string;
+};
+
 export type AddVirtualMemberRequest = {
     member_key: string;
     priority?: number | null;
@@ -66,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;
@@ -240,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;
@@ -264,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;
@@ -447,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;
@@ -518,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 = {
@@ -534,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?: {
@@ -551,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;
@@ -675,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;
@@ -938,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;
 };
@@ -1026,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;
@@ -1083,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;
@@ -1131,11 +1384,45 @@ 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;
 };
 
+export type LabelEntrySchema = {
+    key: string;
+    value?: string;
+};
+
+export type LabelResponse = {
+    created_at: string;
+    id: string;
+    key: string;
+    repository_id: string;
+    value: string;
+};
+
+export type LabelsListResponse = {
+    items: Array<LabelResponse>;
+    total: number;
+};
+
 export type LdapConfigResponse = {
     admin_group_dn?: string | null;
     bind_dn?: string | null;
@@ -1271,6 +1558,13 @@ export type ListUsersQuery = {
     search?: string | null;
 };
 
+/**
+ * Lightweight liveness response.
+ */
+export type LivezResponse = {
+    status: string;
+};
+
 export type LoginRequest = {
     password: string;
     username: string;
@@ -1286,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>;
 };
@@ -1537,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;
@@ -1552,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;
@@ -1654,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;
 };
 
@@ -1666,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;
@@ -1689,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;
 };
 
@@ -1697,6 +2065,7 @@ export type PromotionHistoryQuery = {
     artifact_id?: string | null;
     page?: number | null;
     per_page?: number | null;
+    status?: string | null;
 };
 
 export type PromotionHistoryResponse = {
@@ -1713,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;
 };
@@ -1738,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;
@@ -1745,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;
@@ -1839,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>;
 };
@@ -1850,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;
@@ -1989,6 +2445,14 @@ export type ServiceHealthEntry = {
     status: string;
 };
 
+export type SetLabelsRequest = {
+    labels: Array<LabelEntrySchema>;
+};
+
+export type SetPeerLabelsRequest = {
+    labels: Array<PeerLabelEntrySchema>;
+};
+
 /**
  * Response body for the setup status endpoint.
  */
@@ -2099,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;
@@ -2200,6 +2694,10 @@ export type TicketResponse = {
     ticket: string;
 };
 
+export type TogglePolicyPayload = {
+    enabled: boolean;
+};
+
 export type ToggleRequest = {
     enabled: boolean;
 };
@@ -2256,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;
@@ -2298,6 +2806,23 @@ export type UpdateCveStatusRequest = {
     status: string;
 };
 
+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;
@@ -2340,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?: {
@@ -2375,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;
@@ -3911,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: {
@@ -6332,6 +7092,126 @@ export type HeartbeatResponses = {
     200: unknown;
 };
 
+export type ListLabelsData = {
+    body?: never;
+    path: {
+        /**
+         * Peer instance ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/peers/{id}/labels';
+};
+
+export type ListLabelsErrors = {
+    /**
+     * Peer instance not found
+     */
+    404: unknown;
+};
+
+export type ListLabelsResponses = {
+    /**
+     * Labels retrieved
+     */
+    200: PeerLabelsListResponse;
+};
+
+export type ListLabelsResponse = ListLabelsResponses[keyof ListLabelsResponses];
+
+export type SetLabelsData = {
+    body: SetPeerLabelsRequest;
+    path: {
+        /**
+         * Peer instance ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/peers/{id}/labels';
+};
+
+export type SetLabelsErrors = {
+    /**
+     * Peer instance not found
+     */
+    404: unknown;
+};
+
+export type SetLabelsResponses = {
+    /**
+     * Labels updated
+     */
+    200: PeerLabelsListResponse;
+};
+
+export type SetLabelsResponse = SetLabelsResponses[keyof SetLabelsResponses];
+
+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}/labels/{label_key}';
+};
+
+export type DeleteLabelErrors = {
+    /**
+     * Peer instance or label not found
+     */
+    404: unknown;
+};
+
+export type DeleteLabelResponses = {
+    /**
+     * Label removed
+     */
+    204: void;
+};
+
+export type DeleteLabelResponse = DeleteLabelResponses[keyof DeleteLabelResponses];
+
+export type AddLabelData = {
+    body: AddPeerLabelRequest;
+    path: {
+        /**
+         * Peer instance ID
+         */
+        id: string;
+        /**
+         * Label key to set
+         */
+        label_key: string;
+    };
+    query?: never;
+    url: '/api/v1/peers/{id}/labels/{label_key}';
+};
+
+export type AddLabelErrors = {
+    /**
+     * Peer instance not found
+     */
+    404: unknown;
+};
+
+export type AddLabelResponses = {
+    /**
+     * Label added/updated
+     */
+    200: PeerLabelResponse;
+};
+
+export type AddLabelResponse = AddLabelResponses[keyof AddLabelResponses];
+
 export type UpdateNetworkProfileData = {
     body: NetworkProfileBody;
     path: {
@@ -7183,83 +8063,655 @@ export type ReloadPluginResponses = {
 
 export type ReloadPluginResponse = ReloadPluginResponses[keyof ReloadPluginResponses];
 
-export type PromoteArtifactData = {
+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: {
         /**
-         * Source repository key
-         */
-        key: string;
-        /**
-         * Artifact ID to promote
+         * Source repository key
+         */
+        key: string;
+        /**
+         * Artifact ID to promote
+         */
+        artifact_id: string;
+    };
+    query?: never;
+    url: '/api/v1/promotion/repositories/{key}/artifacts/{artifact_id}/promote';
+};
+
+export type PromoteArtifactErrors = {
+    /**
+     * Artifact or repository not found
+     */
+    404: ErrorResponse;
+    /**
+     * Artifact already exists in target
+     */
+    409: ErrorResponse;
+    /**
+     * Validation error (repo type/format mismatch)
+     */
+    422: ErrorResponse;
+};
+
+export type PromoteArtifactError = PromoteArtifactErrors[keyof PromoteArtifactErrors];
+
+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
          */
-        artifact_id: string;
+        id: string;
     };
     query?: never;
-    url: '/api/v1/promotion/repositories/{key}/artifacts/{artifact_id}/promote';
+    url: '/api/v1/quality/gates/{id}';
 };
 
-export type PromoteArtifactErrors = {
+export type GetGateErrors = {
     /**
-     * Artifact or repository not found
+     * Quality gate not found
      */
     404: ErrorResponse;
+};
+
+export type GetGateError = GetGateErrors[keyof GetGateErrors];
+
+export type GetGateResponses = {
     /**
-     * Artifact already exists in target
+     * Quality gate details
      */
-    409: ErrorResponse;
+    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 = {
     /**
-     * Validation error (repo type/format mismatch)
+     * Quality gate not found
      */
-    422: ErrorResponse;
+    404: ErrorResponse;
 };
 
-export type PromoteArtifactError = PromoteArtifactErrors[keyof PromoteArtifactErrors];
+export type UpdateGateError = UpdateGateErrors[keyof UpdateGateErrors];
 
-export type PromoteArtifactResponses = {
+export type UpdateGateResponses = {
     /**
-     * Artifact promotion result
+     * Quality gate updated
      */
-    200: PromotionResponse;
+    200: GateResponse;
 };
 
-export type PromoteArtifactResponse = PromoteArtifactResponses[keyof PromoteArtifactResponses];
+export type UpdateGateResponse = UpdateGateResponses[keyof UpdateGateResponses];
 
-export type PromoteArtifactsBulkData = {
-    body: BulkPromoteRequest;
+export type GetArtifactHealthData = {
+    body?: never;
     path: {
         /**
-         * Source repository key
+         * Artifact ID
          */
-        key: string;
+        artifact_id: string;
     };
     query?: never;
-    url: '/api/v1/promotion/repositories/{key}/promote';
+    url: '/api/v1/quality/health/artifacts/{artifact_id}';
 };
 
-export type PromoteArtifactsBulkErrors = {
+export type GetArtifactHealthErrors = {
     /**
-     * Repository not found
+     * Artifact not found
      */
     404: ErrorResponse;
+};
+
+export type GetArtifactHealthError = GetArtifactHealthErrors[keyof GetArtifactHealthErrors];
+
+export type GetArtifactHealthResponses = {
     /**
-     * Validation error (repo type/format mismatch)
+     * Artifact health score
      */
-    422: ErrorResponse;
+    200: ArtifactHealthResponse;
 };
 
-export type PromoteArtifactsBulkError = PromoteArtifactsBulkErrors[keyof PromoteArtifactsBulkErrors];
+export type GetArtifactHealthResponse = GetArtifactHealthResponses[keyof GetArtifactHealthResponses];
 
-export type PromoteArtifactsBulkResponses = {
+export type GetHealthDashboardData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/quality/health/dashboard';
+};
+
+export type GetHealthDashboardResponses = {
     /**
-     * Bulk promotion results
+     * Health dashboard summary
      */
-    200: BulkPromotionResponse;
+    200: HealthDashboardResponse;
 };
 
-export type PromoteArtifactsBulkResponse = PromoteArtifactsBulkResponses[keyof PromoteArtifactsBulkResponses];
+export type GetHealthDashboardResponse = GetHealthDashboardResponses[keyof GetHealthDashboardResponses];
 
-export type PromotionHistoryData = {
+export type GetRepoHealthData = {
     body?: never;
     path: {
         /**
@@ -7267,40 +8719,87 @@ export type PromotionHistoryData = {
          */
         key: string;
     };
-    query?: {
-        /**
-         * Page number (1-indexed)
-         */
-        page?: number;
+    query?: never;
+    url: '/api/v1/quality/health/repositories/{key}';
+};
+
+export type GetRepoHealthErrors = {
+    /**
+     * Repository not found
+     */
+    404: ErrorResponse;
+};
+
+export type GetRepoHealthError = GetRepoHealthErrors[keyof GetRepoHealthErrors];
+
+export type GetRepoHealthResponses = {
+    /**
+     * Repository health score
+     */
+    200: RepoHealthResponse;
+};
+
+export type GetRepoHealthResponse = GetRepoHealthResponses[keyof GetRepoHealthResponses];
+
+export type UnsuppressIssueData = {
+    body?: never;
+    path: {
         /**
-         * Items per page (max 100)
+         * Issue ID
          */
-        per_page?: number;
+        id: string;
+    };
+    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;
@@ -7430,6 +8929,10 @@ export type UpdateRepositoryErrors = {
      * Repository not found
      */
     404: unknown;
+    /**
+     * Repository key already exists
+     */
+    409: unknown;
 };
 
 export type UpdateRepositoryResponses = {
@@ -7455,158 +8958,278 @@ export type ListArtifactsData = {
         q?: string | null;
         path_prefix?: string | null;
     };
-    url: '/api/v1/repositories/{key}/artifacts';
+    url: '/api/v1/repositories/{key}/artifacts';
+};
+
+export type ListArtifactsErrors = {
+    /**
+     * Repository not found
+     */
+    404: unknown;
+};
+
+export type ListArtifactsResponses = {
+    /**
+     * List of artifacts
+     */
+    200: ArtifactListResponse;
+};
+
+export type ListArtifactsResponse = ListArtifactsResponses[keyof ListArtifactsResponses];
+
+export type DeleteArtifactData = {
+    body?: never;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+        /**
+         * Artifact path
+         */
+        path: string;
+    };
+    query?: never;
+    url: '/api/v1/repositories/{key}/artifacts/{path}';
+};
+
+export type DeleteArtifactErrors = {
+    /**
+     * Authentication required
+     */
+    401: unknown;
+    /**
+     * Artifact not found
+     */
+    404: unknown;
+};
+
+export type DeleteArtifactResponses = {
+    /**
+     * Artifact deleted
+     */
+    200: unknown;
+};
+
+export type GetRepositoryArtifactMetadataData = {
+    body?: never;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+        /**
+         * Artifact path
+         */
+        path: string;
+    };
+    query?: never;
+    url: '/api/v1/repositories/{key}/artifacts/{path}';
+};
+
+export type GetRepositoryArtifactMetadataErrors = {
+    /**
+     * Artifact not found
+     */
+    404: unknown;
+};
+
+export type GetRepositoryArtifactMetadataResponses = {
+    /**
+     * Artifact metadata
+     */
+    200: ArtifactResponse;
+};
+
+export type GetRepositoryArtifactMetadataResponse = GetRepositoryArtifactMetadataResponses[keyof GetRepositoryArtifactMetadataResponses];
+
+export type UploadArtifactData = {
+    body: Array<number>;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+        /**
+         * Artifact path
+         */
+        path: string;
+    };
+    query?: never;
+    url: '/api/v1/repositories/{key}/artifacts/{path}';
+};
+
+export type UploadArtifactErrors = {
+    /**
+     * Authentication required
+     */
+    401: unknown;
+    /**
+     * Repository not found
+     */
+    404: unknown;
+};
+
+export type UploadArtifactResponses = {
+    /**
+     * Artifact uploaded
+     */
+    200: ArtifactResponse;
+};
+
+export type UploadArtifactResponse = UploadArtifactResponses[keyof UploadArtifactResponses];
+
+export type DownloadArtifactData = {
+    body?: never;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+        /**
+         * Artifact path
+         */
+        path: string;
+    };
+    query?: never;
+    url: '/api/v1/repositories/{key}/download/{path}';
 };
 
-export type ListArtifactsErrors = {
+export type DownloadArtifactErrors = {
     /**
-     * Repository not found
+     * Artifact not found
      */
     404: unknown;
 };
 
-export type ListArtifactsResponses = {
+export type DownloadArtifactResponses = {
     /**
-     * List of artifacts
+     * Artifact binary content
      */
-    200: ArtifactListResponse;
+    200: Blob | File;
 };
 
-export type ListArtifactsResponse = ListArtifactsResponses[keyof ListArtifactsResponses];
+export type DownloadArtifactResponse = DownloadArtifactResponses[keyof DownloadArtifactResponses];
 
-export type DeleteArtifactData = {
+export type ListRepoLabelsData = {
     body?: never;
     path: {
         /**
          * Repository key
          */
         key: string;
-        /**
-         * Artifact path
-         */
-        path: string;
     };
     query?: never;
-    url: '/api/v1/repositories/{key}/artifacts/{path}';
+    url: '/api/v1/repositories/{key}/labels';
 };
 
-export type DeleteArtifactErrors = {
-    /**
-     * Authentication required
-     */
-    401: unknown;
+export type ListRepoLabelsErrors = {
     /**
-     * Artifact not found
+     * Repository not found
      */
     404: unknown;
 };
 
-export type DeleteArtifactResponses = {
+export type ListRepoLabelsResponses = {
     /**
-     * Artifact deleted
+     * Labels retrieved
      */
-    200: unknown;
+    200: LabelsListResponse;
 };
 
-export type GetRepositoryArtifactMetadataData = {
-    body?: never;
+export type ListRepoLabelsResponse = ListRepoLabelsResponses[keyof ListRepoLabelsResponses];
+
+export type SetRepoLabelsData = {
+    body: SetLabelsRequest;
     path: {
         /**
          * Repository key
          */
         key: string;
-        /**
-         * Artifact path
-         */
-        path: string;
     };
     query?: never;
-    url: '/api/v1/repositories/{key}/artifacts/{path}';
+    url: '/api/v1/repositories/{key}/labels';
 };
 
-export type GetRepositoryArtifactMetadataErrors = {
+export type SetRepoLabelsErrors = {
     /**
-     * Artifact not found
+     * Repository not found
      */
     404: unknown;
 };
 
-export type GetRepositoryArtifactMetadataResponses = {
+export type SetRepoLabelsResponses = {
     /**
-     * Artifact metadata
+     * Labels updated
      */
-    200: ArtifactResponse;
+    200: LabelsListResponse;
 };
 
-export type GetRepositoryArtifactMetadataResponse = GetRepositoryArtifactMetadataResponses[keyof GetRepositoryArtifactMetadataResponses];
+export type SetRepoLabelsResponse = SetRepoLabelsResponses[keyof SetRepoLabelsResponses];
 
-export type UploadArtifactData = {
-    body: Array<number>;
+export type DeleteRepoLabelData = {
+    body?: never;
     path: {
         /**
          * Repository key
          */
         key: string;
         /**
-         * Artifact path
+         * Label key to remove
          */
-        path: string;
+        label_key: string;
     };
     query?: never;
-    url: '/api/v1/repositories/{key}/artifacts/{path}';
+    url: '/api/v1/repositories/{key}/labels/{label_key}';
 };
 
-export type UploadArtifactErrors = {
-    /**
-     * Authentication required
-     */
-    401: unknown;
+export type DeleteRepoLabelErrors = {
     /**
-     * Repository not found
+     * Repository or label not found
      */
     404: unknown;
 };
 
-export type UploadArtifactResponses = {
+export type DeleteRepoLabelResponses = {
     /**
-     * Artifact uploaded
+     * Label removed
      */
-    200: ArtifactResponse;
+    204: void;
 };
 
-export type UploadArtifactResponse = UploadArtifactResponses[keyof UploadArtifactResponses];
+export type DeleteRepoLabelResponse = DeleteRepoLabelResponses[keyof DeleteRepoLabelResponses];
 
-export type DownloadArtifactData = {
-    body?: never;
+export type AddRepoLabelData = {
+    body: AddLabelRequest;
     path: {
         /**
          * Repository key
          */
         key: string;
         /**
-         * Artifact path
+         * Label key to set
          */
-        path: string;
+        label_key: string;
     };
     query?: never;
-    url: '/api/v1/repositories/{key}/download/{path}';
+    url: '/api/v1/repositories/{key}/labels/{label_key}';
 };
 
-export type DownloadArtifactErrors = {
+export type AddRepoLabelErrors = {
     /**
-     * Artifact not found
+     * Repository not found
      */
     404: unknown;
 };
 
-export type DownloadArtifactResponses = {
+export type AddRepoLabelResponses = {
     /**
-     * Artifact binary content
+     * Label added/updated
      */
-    200: Blob | File;
+    200: LabelResponse;
 };
 
-export type DownloadArtifactResponse = DownloadArtifactResponses[keyof DownloadArtifactResponses];
+export type AddRepoLabelResponse = AddRepoLabelResponses[keyof AddRepoLabelResponses];
 
 export type ListVirtualMembersData = {
     body?: never;
@@ -9106,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;
@@ -9791,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];