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

package/src/types.gen.ts

@@ -8,6 +8,10 @@ export type AcknowledgeRequest = {
     reason: string;
 };
 
+export type AddArtifactLabelRequest = {
+    value?: string;
+};
+
 export type AddBuildArtifactsRequest = {
     artifacts: Array<BuildArtifactInputPayload>;
 };
@@ -20,11 +24,28 @@ export type AddLabelRequest = {
     value?: string;
 };
 
+export type AddPeerLabelRequest = {
+    value?: string;
+};
+
 export type AddVirtualMemberRequest = {
     member_key: string;
     priority?: number | null;
 };
 
+export type AdminUserResponse = {
+    auth_provider: string;
+    created_at: string;
+    display_name?: string | null;
+    email: string;
+    id: string;
+    is_active: boolean;
+    is_admin: boolean;
+    last_login_at?: string | null;
+    must_change_password: boolean;
+    username: string;
+};
+
 export type AdvancedSearchResponse = {
     facets: FacetsResponse;
     items: Array<SearchResultItem>;
@@ -70,6 +91,112 @@ 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>;
+    /**
+     * Tag selectors (AND semantics). Key = tag key, value = required tag value.
+     * Empty value means "key must exist with any value".
+     */
+    match_tags?: {
+        [key: string]: 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 ArtifactLabelEntrySchema = {
+    key: string;
+    value?: string;
+};
+
+export type ArtifactLabelResponse = {
+    artifact_id: string;
+    created_at: string;
+    id: string;
+    key: string;
+    value: string;
+};
+
+export type ArtifactLabelsListResponse = {
+    items: Array<ArtifactLabelResponse>;
+    total: number;
+};
+
 export type ArtifactListResponse = {
     items: Array<ArtifactResponse>;
     pagination: Pagination;
@@ -244,6 +371,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 +404,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;
@@ -316,12 +485,14 @@ export type CleanupRequest = {
     cleanup_audit_logs?: boolean | null;
     cleanup_old_backups?: boolean | null;
     cleanup_stale_peers?: boolean | null;
+    cleanup_stale_uploads?: boolean | null;
 };
 
 export type CleanupResponse = {
     audit_logs_deleted: number;
     backups_deleted: number;
     peers_marked_offline: number;
+    stale_uploads_deleted: number;
 };
 
 export type CompleteChunkBody = {
@@ -451,6 +622,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,14 +710,21 @@ 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 = {
     description?: string | null;
     format: string;
+    /**
+     * Custom format key for WASM plugin format handlers (e.g. "rpm-custom").
+     */
+    format_key?: string | null;
     is_public?: boolean | null;
     key: string;
     name: string;
@@ -538,6 +733,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,11 +764,66 @@ export type CreateSamlConfigRequest = {
     sso_url: string;
 };
 
+export type CreateServiceAccountRequest = {
+    /**
+     * Optional description
+     */
+    description?: string | null;
+    /**
+     * Name for the service account (will be prefixed with "svc-")
+     */
+    name: 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;
 };
 
+export type CreateTokenRequest = {
+    description?: string | null;
+    expires_in_days?: number | null;
+    name: string;
+    /**
+     * Dynamic repository selector (match by labels, formats, name pattern).
+     * Mutually exclusive with `repository_ids`. When set, matched repos are
+     * resolved at auth time so new repos that match the selector are picked up
+     * automatically.
+     */
+    repo_selector?: {
+        [key: string]: unknown;
+    } | null;
+    /**
+     * Explicit repository IDs to restrict access to. Mutually exclusive with `repo_selector`.
+     */
+    repository_ids?: Array<string> | null;
+    scopes: Array<string>;
+};
+
+export type CreateTokenResponse = {
+    id: string;
+    name: string;
+    token: string;
+};
+
 export type CreateUserRequest = {
     display_name?: string | null;
     email: string;
@@ -570,7 +834,7 @@ export type CreateUserRequest = {
 
 export type CreateUserResponse = {
     generated_password?: string | null;
-    user: UserResponse;
+    user: AdminUserResponse;
 };
 
 export type CreateWebhookRequest = {
@@ -679,6 +943,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 +1216,14 @@ export type ErrorResponse = {
     message: string;
 };
 
+export type EvaluationResultResponse = {
+    created: number;
+    policies_evaluated: number;
+    removed: number;
+    retroactive_tasks_queued: number;
+    updated: number;
+};
+
 export type EventsQuery = {
     limit?: number | null;
 };
@@ -1030,6 +1312,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 +1409,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 +1470,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 +1644,13 @@ export type ListUsersQuery = {
     search?: string | null;
 };
 
+/**
+ * Lightweight liveness response.
+ */
+export type LivezResponse = {
+    status: string;
+};
+
 export type LoginRequest = {
     password: string;
     username: string;
@@ -1308,6 +1666,27 @@ export type LoginResponse = {
     totp_token?: string | null;
 };
 
+export type MatchedPeerSchema = {
+    id: string;
+    name: string;
+    region?: string | null;
+};
+
+/**
+ * A single matched repository in the preview response.
+ */
+export type MatchedRepoResponse = {
+    format: string;
+    id: string;
+    key: string;
+};
+
+export type MatchedRepoSchema = {
+    format: string;
+    id: string;
+    key: string;
+};
+
 export type MembersRequest = {
     user_ids: Array<string>;
 };
@@ -1559,6 +1938,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 +1971,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 +2088,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 +2103,50 @@ 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;
+    };
+};
+
+/**
+ * Request body for previewing which repositories a selector matches.
+ */
+export type PreviewRepoSelectorRequest = {
+    /**
+     * The repository selector to evaluate.
+     */
+    repo_selector: {
+        [key: string]: unknown;
+    };
+};
+
+/**
+ * Response for the repo selector preview endpoint.
+ */
+export type PreviewRepoSelectorResponse = {
+    matched_repositories: Array<MatchedRepoResponse>;
+    total: number;
+};
+
+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 +2170,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 +2180,7 @@ export type PromotionHistoryQuery = {
     artifact_id?: string | null;
     page?: number | null;
     per_page?: number | null;
+    status?: string | null;
 };
 
 export type PromotionHistoryResponse = {
@@ -1735,8 +2197,44 @@ export type PromotionResponse = {
     target: string;
 };
 
-export type QuickSearchResponse = {
-    results: Array<SearchResultItem>;
+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 = {
@@ -1760,6 +2258,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 +2278,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 +2396,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 +2414,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;
@@ -1999,6 +2548,29 @@ export type SearchResultItem = {
     version?: string | null;
 };
 
+export type ServiceAccountListResponse = {
+    items: Array<ServiceAccountSummaryResponse>;
+};
+
+export type ServiceAccountResponse = {
+    created_at: string;
+    display_name?: string | null;
+    id: string;
+    is_active: boolean;
+    updated_at: string;
+    username: string;
+};
+
+export type ServiceAccountSummaryResponse = {
+    created_at: string;
+    display_name?: string | null;
+    id: string;
+    is_active: boolean;
+    token_count: number;
+    updated_at: string;
+    username: string;
+};
+
 /**
  * A health check result for a single service.
  */
@@ -2011,10 +2583,18 @@ export type ServiceHealthEntry = {
     status: string;
 };
 
+export type SetArtifactLabelsRequest = {
+    labels: Array<ArtifactLabelEntrySchema>;
+};
+
 export type SetLabelsRequest = {
     labels: Array<LabelEntrySchema>;
 };
 
+export type SetPeerLabelsRequest = {
+    labels: Array<PeerLabelEntrySchema>;
+};
+
 /**
  * Response body for the setup status endpoint.
  */
@@ -2101,6 +2681,27 @@ export type StaleQuery = {
     limit?: number | null;
 };
 
+/**
+ * Request body for storage GC.
+ */
+export type StorageGcRequest = {
+    /**
+     * When true, report what would be deleted without actually deleting.
+     */
+    dry_run?: boolean;
+};
+
+/**
+ * Result of a storage GC run.
+ */
+export type StorageGcResult = {
+    artifacts_removed: number;
+    bytes_freed: number;
+    dry_run: boolean;
+    errors: Array<string>;
+    storage_keys_deleted: number;
+};
+
 /**
  * A single day's storage metrics snapshot.
  */
@@ -2125,11 +2726,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,10 +2857,39 @@ export type TicketResponse = {
     ticket: string;
 };
 
+export type TogglePolicyPayload = {
+    enabled: boolean;
+};
+
 export type ToggleRequest = {
     enabled: boolean;
 };
 
+export type TokenInfoResponse = {
+    created_at: string;
+    expires_at?: string | null;
+    id: string;
+    is_expired: boolean;
+    last_used_at?: string | null;
+    name: string;
+    /**
+     * Dynamic repository selector, if configured.
+     */
+    repo_selector?: {
+        [key: string]: unknown;
+    } | null;
+    /**
+     * Explicit repository IDs this token is restricted to (from join table).
+     */
+    repository_ids: Array<string>;
+    scopes: Array<string>;
+    token_prefix: string;
+};
+
+export type TokenListResponse = {
+    items: Array<TokenInfoResponse>;
+};
+
 export type TotpCodeRequest = {
     code: string;
 };
@@ -2282,6 +2942,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,6 +2994,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;
@@ -2366,17 +3053,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?: {
@@ -2394,6 +3097,11 @@ export type UpdateSamlConfigRequest = {
     sso_url?: string | null;
 };
 
+export type UpdateServiceAccountRequest = {
+    display_name?: string | null;
+    is_active?: boolean | null;
+};
+
 export type UpdateSigningConfigPayload = {
     require_signatures?: boolean | null;
     sign_metadata?: boolean | null;
@@ -2401,6 +3109,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;
@@ -2435,7 +3161,7 @@ export type UpsertScanConfigRequest = {
 };
 
 export type UserListResponse = {
-    items: Array<UserResponse>;
+    items: Array<AdminUserResponse>;
     pagination: Pagination;
 };
 
@@ -3814,6 +4540,22 @@ export type GetSystemStatsResponses = {
 
 export type GetSystemStatsResponse = GetSystemStatsResponses[keyof GetSystemStatsResponses];
 
+export type RunStorageGcData = {
+    body: StorageGcRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/admin/storage-gc';
+};
+
+export type RunStorageGcResponses = {
+    /**
+     * GC result
+     */
+    200: StorageGcResult;
+};
+
+export type RunStorageGcResponse = RunStorageGcResponses[keyof RunStorageGcResponses];
+
 export type ListCrashesData = {
     body?: never;
     path?: never;
@@ -3937,102 +4679,423 @@ export type UpdateTelemetrySettingsResponses = {
 
 export type UpdateTelemetrySettingsResponse = UpdateTelemetrySettingsResponses[keyof UpdateTelemetrySettingsResponses];
 
-export type GetArtifactData = {
+export type ListApprovalHistoryData = {
     body?: never;
-    path: {
+    path?: never;
+    query?: {
         /**
-         * Artifact ID
+         * Page number (1-indexed)
          */
-        id: string;
+        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/artifacts/{id}';
+    url: '/api/v1/approval/request';
 };
 
-export type GetArtifactErrors = {
+export type RequestApprovalErrors = {
     /**
-     * Artifact not found
+     * Artifact or repository not found
      */
     404: ErrorResponse;
+    /**
+     * Pending approval already exists
+     */
+    409: ErrorResponse;
+    /**
+     * Validation error
+     */
+    422: ErrorResponse;
 };
 
-export type GetArtifactError = GetArtifactErrors[keyof GetArtifactErrors];
+export type RequestApprovalError = RequestApprovalErrors[keyof RequestApprovalErrors];
 
-export type GetArtifactResponses = {
+export type RequestApprovalResponses = {
     /**
-     * Artifact details
+     * Approval request created
      */
-    200: ArtifactResponse;
+    201: ApprovalResponse;
 };
 
-export type GetArtifactResponse = GetArtifactResponses[keyof GetArtifactResponses];
+export type RequestApprovalResponse = RequestApprovalResponses[keyof RequestApprovalResponses];
 
-export type GetArtifactMetadataData = {
+export type GetApprovalData = {
     body?: never;
     path: {
         /**
-         * Artifact ID
+         * Approval request ID
          */
         id: string;
     };
     query?: never;
-    url: '/api/v1/artifacts/{id}/metadata';
+    url: '/api/v1/approval/{id}';
 };
 
-export type GetArtifactMetadataErrors = {
+export type GetApprovalErrors = {
     /**
-     * Artifact or metadata not found
+     * Approval request not found
      */
     404: ErrorResponse;
 };
 
-export type GetArtifactMetadataError = GetArtifactMetadataErrors[keyof GetArtifactMetadataErrors];
+export type GetApprovalError = GetApprovalErrors[keyof GetApprovalErrors];
 
-export type GetArtifactMetadataResponses = {
+export type GetApprovalResponses = {
     /**
-     * Artifact metadata
+     * Approval request details
      */
-    200: ArtifactMetadataResponse;
+    200: ApprovalResponse;
 };
 
-export type GetArtifactMetadataResponse = GetArtifactMetadataResponses[keyof GetArtifactMetadataResponses];
+export type GetApprovalResponse = GetApprovalResponses[keyof GetApprovalResponses];
 
-export type GetArtifactStatsData = {
-    body?: never;
+export type ApprovePromotionData = {
+    body: ReviewRequest;
     path: {
         /**
-         * Artifact ID
+         * Approval request ID
          */
         id: string;
     };
     query?: never;
-    url: '/api/v1/artifacts/{id}/stats';
+    url: '/api/v1/approval/{id}/approve';
 };
 
-export type GetArtifactStatsErrors = {
+export type ApprovePromotionErrors = {
     /**
-     * Artifact not found
+     * Admin access required
+     */
+    403: ErrorResponse;
+    /**
+     * Approval request not found
      */
     404: ErrorResponse;
+    /**
+     * Approval already reviewed
+     */
+    409: ErrorResponse;
 };
 
-export type GetArtifactStatsError = GetArtifactStatsErrors[keyof GetArtifactStatsErrors];
+export type ApprovePromotionError = ApprovePromotionErrors[keyof ApprovePromotionErrors];
 
-export type GetArtifactStatsResponses = {
+export type ApprovePromotionResponses = {
     /**
-     * Artifact download statistics
+     * Promotion approved and executed
      */
-    200: ArtifactStatsResponse;
+    200: ApprovalResponse;
 };
 
-export type GetArtifactStatsResponse = GetArtifactStatsResponses[keyof GetArtifactStatsResponses];
+export type ApprovePromotionResponse = ApprovePromotionResponses[keyof ApprovePromotionResponses];
 
-export type LoginData = {
-    body: LoginRequest;
-    path?: never;
-    query?: never;
-    url: '/api/v1/auth/login';
-};
+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: {
+        /**
+         * Artifact ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/artifacts/{id}';
+};
+
+export type GetArtifactErrors = {
+    /**
+     * Artifact not found
+     */
+    404: ErrorResponse;
+};
+
+export type GetArtifactError = GetArtifactErrors[keyof GetArtifactErrors];
+
+export type GetArtifactResponses = {
+    /**
+     * Artifact details
+     */
+    200: ArtifactResponse;
+};
+
+export type GetArtifactResponse = GetArtifactResponses[keyof GetArtifactResponses];
+
+export type ListArtifactLabelsData = {
+    body?: never;
+    path: {
+        /**
+         * Artifact ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/artifacts/{id}/labels';
+};
+
+export type ListArtifactLabelsErrors = {
+    /**
+     * Artifact not found
+     */
+    404: unknown;
+};
+
+export type ListArtifactLabelsResponses = {
+    /**
+     * Labels retrieved
+     */
+    200: ArtifactLabelsListResponse;
+};
+
+export type ListArtifactLabelsResponse = ListArtifactLabelsResponses[keyof ListArtifactLabelsResponses];
+
+export type SetArtifactLabelsData = {
+    body: SetArtifactLabelsRequest;
+    path: {
+        /**
+         * Artifact ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/artifacts/{id}/labels';
+};
+
+export type SetArtifactLabelsErrors = {
+    /**
+     * Artifact not found
+     */
+    404: unknown;
+};
+
+export type SetArtifactLabelsResponses = {
+    /**
+     * Labels updated
+     */
+    200: ArtifactLabelsListResponse;
+};
+
+export type SetArtifactLabelsResponse = SetArtifactLabelsResponses[keyof SetArtifactLabelsResponses];
+
+export type DeleteArtifactLabelData = {
+    body?: never;
+    path: {
+        /**
+         * Artifact ID
+         */
+        id: string;
+        /**
+         * Label key to remove
+         */
+        label_key: string;
+    };
+    query?: never;
+    url: '/api/v1/artifacts/{id}/labels/{label_key}';
+};
+
+export type DeleteArtifactLabelErrors = {
+    /**
+     * Artifact not found
+     */
+    404: unknown;
+};
+
+export type DeleteArtifactLabelResponses = {
+    /**
+     * Label removed
+     */
+    204: void;
+};
+
+export type DeleteArtifactLabelResponse = DeleteArtifactLabelResponses[keyof DeleteArtifactLabelResponses];
+
+export type AddArtifactLabelData = {
+    body: AddArtifactLabelRequest;
+    path: {
+        /**
+         * Artifact ID
+         */
+        id: string;
+        /**
+         * Label key to set
+         */
+        label_key: string;
+    };
+    query?: never;
+    url: '/api/v1/artifacts/{id}/labels/{label_key}';
+};
+
+export type AddArtifactLabelErrors = {
+    /**
+     * Artifact not found
+     */
+    404: unknown;
+};
+
+export type AddArtifactLabelResponses = {
+    /**
+     * Label added/updated
+     */
+    200: ArtifactLabelResponse;
+};
+
+export type AddArtifactLabelResponse = AddArtifactLabelResponses[keyof AddArtifactLabelResponses];
+
+export type GetArtifactMetadataData = {
+    body?: never;
+    path: {
+        /**
+         * Artifact ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/artifacts/{id}/metadata';
+};
+
+export type GetArtifactMetadataErrors = {
+    /**
+     * Artifact or metadata not found
+     */
+    404: ErrorResponse;
+};
+
+export type GetArtifactMetadataError = GetArtifactMetadataErrors[keyof GetArtifactMetadataErrors];
+
+export type GetArtifactMetadataResponses = {
+    /**
+     * Artifact metadata
+     */
+    200: ArtifactMetadataResponse;
+};
+
+export type GetArtifactMetadataResponse = GetArtifactMetadataResponses[keyof GetArtifactMetadataResponses];
+
+export type GetArtifactStatsData = {
+    body?: never;
+    path: {
+        /**
+         * Artifact ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/artifacts/{id}/stats';
+};
+
+export type GetArtifactStatsErrors = {
+    /**
+     * Artifact not found
+     */
+    404: ErrorResponse;
+};
+
+export type GetArtifactStatsError = GetArtifactStatsErrors[keyof GetArtifactStatsErrors];
+
+export type GetArtifactStatsResponses = {
+    /**
+     * Artifact download statistics
+     */
+    200: ArtifactStatsResponse;
+};
+
+export type GetArtifactStatsResponse = GetArtifactStatsResponses[keyof GetArtifactStatsResponses];
+
+export type LoginData = {
+    body: LoginRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/auth/login';
+};
 
 export type LoginErrors = {
     /**
@@ -6358,8 +7421,8 @@ export type HeartbeatResponses = {
     200: unknown;
 };
 
-export type UpdateNetworkProfileData = {
-    body: NetworkProfileBody;
+export type ListLabelsData = {
+    body?: never;
     path: {
         /**
          * Peer instance ID
@@ -6367,18 +7430,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,37 +7458,148 @@ 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}/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: {
+        /**
+         * Peer instance ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/peers/{id}/network-profile';
+};
+
+export type UpdateNetworkProfileResponses = {
+    /**
+     * Network profile updated
+     */
+    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';
 };
@@ -7209,6 +8392,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: {
@@ -7251,82 +8606,529 @@ export type PromoteArtifactResponses = {
 
 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
+         * 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 = {
+    /**
+     * Health dashboard summary
+     */
+    200: HealthDashboardResponse;
+};
+
+export type GetHealthDashboardResponse = GetHealthDashboardResponses[keyof GetHealthDashboardResponses];
+
+export type GetRepoHealthData = {
+    body?: never;
+    path: {
+        /**
+         * Repository key
+         */
+        key: string;
+    };
+    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: {
+        /**
+         * Issue ID
          */
-        key: string;
+        id: string;
     };
     query?: never;
-    url: '/api/v1/promotion/repositories/{key}/promote';
+    url: '/api/v1/quality/issues/{id}/suppress';
 };
 
-export type PromoteArtifactsBulkErrors = {
+export type UnsuppressIssueErrors = {
     /**
-     * Repository not found
+     * Issue not found
      */
     404: ErrorResponse;
-    /**
-     * Validation error (repo type/format mismatch)
-     */
-    422: ErrorResponse;
 };
 
-export type PromoteArtifactsBulkError = PromoteArtifactsBulkErrors[keyof PromoteArtifactsBulkErrors];
+export type UnsuppressIssueError = UnsuppressIssueErrors[keyof UnsuppressIssueErrors];
 
-export type PromoteArtifactsBulkResponses = {
+export type UnsuppressIssueResponses = {
     /**
-     * Bulk promotion results
+     * Issue unsuppressed
      */
-    200: BulkPromotionResponse;
+    200: IssueResponse;
 };
 
-export type PromoteArtifactsBulkResponse = PromoteArtifactsBulkResponses[keyof PromoteArtifactsBulkResponses];
+export type UnsuppressIssueResponse = UnsuppressIssueResponses[keyof UnsuppressIssueResponses];
 
-export type PromotionHistoryData = {
-    body?: never;
+export type SuppressIssueData = {
+    body: SuppressIssueRequest;
     path: {
         /**
-         * Repository key
-         */
-        key: string;
-    };
-    query?: {
-        /**
-         * Page number (1-indexed)
-         */
-        page?: number;
-        /**
-         * Items per page (max 100)
-         */
-        per_page?: number;
-        /**
-         * 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 +9258,10 @@ export type UpdateRepositoryErrors = {
      * Repository not found
      */
     404: unknown;
+    /**
+     * Repository key already exists
+     */
+    409: unknown;
 };
 
 export type UpdateRepositoryResponses = {
@@ -7634,7 +9440,7 @@ export type DownloadArtifactResponses = {
 
 export type DownloadArtifactResponse = DownloadArtifactResponses[keyof DownloadArtifactResponses];
 
-export type ListLabelsData = {
+export type ListRepoLabelsData = {
     body?: never;
     path: {
         /**
@@ -7646,23 +9452,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 +9480,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 +9512,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 +9544,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;
@@ -8810,108 +10616,357 @@ export type TriggerScanResponses = {
     200: TriggerScanResponse;
 };
 
-export type TriggerScanResponse2 = TriggerScanResponses[keyof TriggerScanResponses];
+export type TriggerScanResponse2 = TriggerScanResponses[keyof TriggerScanResponses];
+
+export type ListScansData = {
+    body?: never;
+    path?: never;
+    query?: {
+        repository_id?: string | null;
+        artifact_id?: string | null;
+        status?: string | null;
+        page?: number | null;
+        per_page?: number | null;
+    };
+    url: '/api/v1/security/scans';
+};
+
+export type ListScansResponses = {
+    /**
+     * Paginated list of scans
+     */
+    200: ScanListResponse;
+};
+
+export type ListScansResponse = ListScansResponses[keyof ListScansResponses];
+
+export type GetScanData = {
+    body?: never;
+    path: {
+        /**
+         * Scan result ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/security/scans/{id}';
+};
+
+export type GetScanErrors = {
+    /**
+     * Scan not found
+     */
+    404: ErrorResponse;
+};
+
+export type GetScanError = GetScanErrors[keyof GetScanErrors];
+
+export type GetScanResponses = {
+    /**
+     * Scan details
+     */
+    200: ScanResponse;
+};
+
+export type GetScanResponse = GetScanResponses[keyof GetScanResponses];
+
+export type ListFindingsData = {
+    body?: never;
+    path: {
+        /**
+         * Scan result ID
+         */
+        id: string;
+    };
+    query?: {
+        page?: number | null;
+        per_page?: number | null;
+    };
+    url: '/api/v1/security/scans/{id}/findings';
+};
+
+export type ListFindingsErrors = {
+    /**
+     * Scan not found
+     */
+    404: ErrorResponse;
+};
+
+export type ListFindingsError = ListFindingsErrors[keyof ListFindingsErrors];
+
+export type ListFindingsResponses = {
+    /**
+     * Paginated list of findings for a scan
+     */
+    200: FindingListResponse;
+};
+
+export type ListFindingsResponse = ListFindingsResponses[keyof ListFindingsResponses];
+
+export type GetAllScoresData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/security/scores';
+};
+
+export type GetAllScoresResponses = {
+    /**
+     * All repository security scores
+     */
+    200: Array<ScoreResponse>;
+};
+
+export type GetAllScoresResponse = GetAllScoresResponses[keyof GetAllScoresResponses];
+
+export type ListServiceAccountsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/service-accounts';
+};
+
+export type ListServiceAccountsErrors = {
+    /**
+     * Not admin
+     */
+    403: unknown;
+};
+
+export type ListServiceAccountsResponses = {
+    /**
+     * List of service accounts
+     */
+    200: ServiceAccountListResponse;
+};
+
+export type ListServiceAccountsResponse = ListServiceAccountsResponses[keyof ListServiceAccountsResponses];
+
+export type CreateServiceAccountData = {
+    body: CreateServiceAccountRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/service-accounts';
+};
+
+export type CreateServiceAccountErrors = {
+    /**
+     * Validation error
+     */
+    400: unknown;
+    /**
+     * Not admin
+     */
+    403: unknown;
+};
+
+export type CreateServiceAccountResponses = {
+    /**
+     * Service account created
+     */
+    201: ServiceAccountResponse;
+};
+
+export type CreateServiceAccountResponse = CreateServiceAccountResponses[keyof CreateServiceAccountResponses];
+
+export type PreviewRepoSelectorData = {
+    body: PreviewRepoSelectorRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/service-accounts/repo-selector/preview';
+};
+
+export type PreviewRepoSelectorErrors = {
+    /**
+     * Invalid selector
+     */
+    400: unknown;
+    /**
+     * Not admin
+     */
+    403: unknown;
+};
+
+export type PreviewRepoSelectorResponses = {
+    /**
+     * Matched repositories
+     */
+    200: PreviewRepoSelectorResponse;
+};
+
+export type PreviewRepoSelectorResponse2 = PreviewRepoSelectorResponses[keyof PreviewRepoSelectorResponses];
+
+export type DeleteServiceAccountData = {
+    body?: never;
+    path: {
+        /**
+         * Service account ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/service-accounts/{id}';
+};
+
+export type DeleteServiceAccountErrors = {
+    /**
+     * Not found
+     */
+    404: unknown;
+};
+
+export type DeleteServiceAccountResponses = {
+    /**
+     * Deleted
+     */
+    204: void;
+};
+
+export type DeleteServiceAccountResponse = DeleteServiceAccountResponses[keyof DeleteServiceAccountResponses];
+
+export type GetServiceAccountData = {
+    body?: never;
+    path: {
+        /**
+         * Service account ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/service-accounts/{id}';
+};
+
+export type GetServiceAccountErrors = {
+    /**
+     * Not found
+     */
+    404: unknown;
+};
+
+export type GetServiceAccountResponses = {
+    /**
+     * Service account details
+     */
+    200: ServiceAccountResponse;
+};
+
+export type GetServiceAccountResponse = GetServiceAccountResponses[keyof GetServiceAccountResponses];
 
-export type ListScansData = {
-    body?: never;
-    path?: never;
-    query?: {
-        repository_id?: string | null;
-        artifact_id?: string | null;
-        status?: string | null;
-        page?: number | null;
-        per_page?: number | null;
+export type UpdateServiceAccountData = {
+    body: UpdateServiceAccountRequest;
+    path: {
+        /**
+         * Service account ID
+         */
+        id: string;
     };
-    url: '/api/v1/security/scans';
+    query?: never;
+    url: '/api/v1/service-accounts/{id}';
 };
 
-export type ListScansResponses = {
+export type UpdateServiceAccountErrors = {
     /**
-     * Paginated list of scans
+     * Not found
      */
-    200: ScanListResponse;
+    404: unknown;
 };
 
-export type ListScansResponse = ListScansResponses[keyof ListScansResponses];
+export type UpdateServiceAccountResponses = {
+    /**
+     * Updated
+     */
+    200: ServiceAccountResponse;
+};
 
-export type GetScanData = {
+export type UpdateServiceAccountResponse = UpdateServiceAccountResponses[keyof UpdateServiceAccountResponses];
+
+export type ListTokensData = {
     body?: never;
     path: {
         /**
-         * Scan result ID
+         * Service account ID
          */
         id: string;
     };
     query?: never;
-    url: '/api/v1/security/scans/{id}';
+    url: '/api/v1/service-accounts/{id}/tokens';
 };
 
-export type GetScanErrors = {
+export type ListTokensErrors = {
     /**
-     * Scan not found
+     * Service account not found
      */
-    404: ErrorResponse;
+    404: unknown;
 };
 
-export type GetScanError = GetScanErrors[keyof GetScanErrors];
-
-export type GetScanResponses = {
+export type ListTokensResponses = {
     /**
-     * Scan details
+     * Token list
      */
-    200: ScanResponse;
+    200: TokenListResponse;
 };
 
-export type GetScanResponse = GetScanResponses[keyof GetScanResponses];
+export type ListTokensResponse = ListTokensResponses[keyof ListTokensResponses];
 
-export type ListFindingsData = {
-    body?: never;
+export type CreateTokenData = {
+    body: CreateTokenRequest;
     path: {
         /**
-         * Scan result ID
+         * Service account ID
          */
         id: string;
     };
-    query?: {
-        page?: number | null;
-        per_page?: number | null;
-    };
-    url: '/api/v1/security/scans/{id}/findings';
+    query?: never;
+    url: '/api/v1/service-accounts/{id}/tokens';
 };
 
-export type ListFindingsErrors = {
+export type CreateTokenErrors = {
     /**
-     * Scan not found
+     * Service account not found
      */
-    404: ErrorResponse;
+    404: unknown;
 };
 
-export type ListFindingsError = ListFindingsErrors[keyof ListFindingsErrors];
-
-export type ListFindingsResponses = {
+export type CreateTokenResponses = {
     /**
-     * Paginated list of findings for a scan
+     * Token created (value shown once)
      */
-    200: FindingListResponse;
+    200: CreateTokenResponse;
 };
 
-export type ListFindingsResponse = ListFindingsResponses[keyof ListFindingsResponses];
+export type CreateTokenResponse2 = CreateTokenResponses[keyof CreateTokenResponses];
 
-export type GetAllScoresData = {
+export type RevokeTokenData = {
     body?: never;
-    path?: never;
+    path: {
+        /**
+         * Service account ID
+         */
+        id: string;
+        /**
+         * Token ID
+         */
+        token_id: string;
+    };
     query?: never;
-    url: '/api/v1/security/scores';
+    url: '/api/v1/service-accounts/{id}/tokens/{token_id}';
 };
 
-export type GetAllScoresResponses = {
+export type RevokeTokenErrors = {
     /**
-     * All repository security scores
+     * Not found
      */
-    200: Array<ScoreResponse>;
+    404: unknown;
 };
 
-export type GetAllScoresResponse = GetAllScoresResponses[keyof GetAllScoresResponses];
+export type RevokeTokenResponses = {
+    /**
+     * Token revoked
+     */
+    204: void;
+};
+
+export type RevokeTokenResponse = RevokeTokenResponses[keyof RevokeTokenResponses];
 
 export type SetupStatusData = {
     body?: never;
@@ -9252,6 +11307,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;
@@ -9396,7 +11683,7 @@ export type GetUserResponses = {
     /**
      * User details
      */
-    200: UserResponse;
+    200: AdminUserResponse;
 };
 
 export type GetUserResponse = GetUserResponses[keyof GetUserResponses];
@@ -9424,7 +11711,7 @@ export type UpdateUserResponses = {
     /**
      * User updated successfully
      */
-    200: UserResponse;
+    200: AdminUserResponse;
 };
 
 export type UpdateUserResponse = UpdateUserResponses[keyof UpdateUserResponses];
@@ -9937,23 +12224,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];