@native-knowledge/knowledge-sdk 0.0.0-stage → 0.1.0-rc.1

package/dist/types/contracts/source-governance.d.ts

@@ -0,0 +1,375 @@
+import { z } from 'zod';
+export declare const sourceExpectationSchema: z.ZodEnum<{
+    REQUIRED: "REQUIRED";
+    OPTIONAL: "OPTIONAL";
+    CONDITIONAL: "CONDITIONAL";
+}>;
+export declare const sourceDeclaredStateSchema: z.ZodEnum<{
+    ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+    CONFIGURED: "CONFIGURED";
+    PENDING_DISCOVERY: "PENDING_DISCOVERY";
+    KNOWN_MISSING: "KNOWN_MISSING";
+    NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+    DEFERRED: "DEFERRED";
+    RETIRED: "RETIRED";
+}>;
+export declare const sourceCoverageStateSchema: z.ZodEnum<{
+    ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+    PARTIAL: "PARTIAL";
+    ACQUIRED: "ACQUIRED";
+    BLOCKED: "BLOCKED";
+    PENDING_DISCOVERY: "PENDING_DISCOVERY";
+    KNOWN_MISSING: "KNOWN_MISSING";
+    NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+    DEFERRED: "DEFERRED";
+    RETIRED: "RETIRED";
+    CONFIGURED_UNOBSERVED: "CONFIGURED_UNOBSERVED";
+}>;
+export declare const sourceDiscoveryPolicySchema: z.ZodObject<{
+    hostMode: z.ZodDefault<z.ZodEnum<{
+        ALLOWLIST: "ALLOWLIST";
+        EVIDENCE_OBSERVED: "EVIDENCE_OBSERVED";
+    }>>;
+    allowedHosts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    forbiddenHostSuffixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    allowedPathPrefixes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const sourceUniverseEntrySchema: z.ZodObject<{
+    sourceId: z.ZodString;
+    familyId: z.ZodString;
+    acquisitionSourceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    expectation: z.ZodEnum<{
+        REQUIRED: "REQUIRED";
+        OPTIONAL: "OPTIONAL";
+        CONDITIONAL: "CONDITIONAL";
+    }>;
+    authority: z.ZodString;
+    access: z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>;
+    freshness: z.ZodString;
+    semanticRoles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    locator: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    declaredState: z.ZodEnum<{
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        CONFIGURED: "CONFIGURED";
+        PENDING_DISCOVERY: "PENDING_DISCOVERY";
+        KNOWN_MISSING: "KNOWN_MISSING";
+        NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+        DEFERRED: "DEFERRED";
+        RETIRED: "RETIRED";
+    }>;
+    expectedOwner: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    requiredFor: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    discoveryPolicy: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        hostMode: z.ZodDefault<z.ZodEnum<{
+            ALLOWLIST: "ALLOWLIST";
+            EVIDENCE_OBSERVED: "EVIDENCE_OBSERVED";
+        }>>;
+        allowedHosts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        forbiddenHostSuffixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        allowedPathPrefixes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+    notes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export declare const sourceUniverseSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    asOf: z.ZodISODateTime;
+    sources: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        familyId: z.ZodString;
+        acquisitionSourceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        expectation: z.ZodEnum<{
+            REQUIRED: "REQUIRED";
+            OPTIONAL: "OPTIONAL";
+            CONDITIONAL: "CONDITIONAL";
+        }>;
+        authority: z.ZodString;
+        access: z.ZodEnum<{
+            PUBLIC: "PUBLIC";
+            PUBLIC_METADATA: "PUBLIC_METADATA";
+            TENANT: "TENANT";
+            INTERNAL: "INTERNAL";
+            FDE_INTERNAL: "FDE_INTERNAL";
+            ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+            UNKNOWN: "UNKNOWN";
+        }>;
+        freshness: z.ZodString;
+        semanticRoles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        locator: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        declaredState: z.ZodEnum<{
+            ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+            CONFIGURED: "CONFIGURED";
+            PENDING_DISCOVERY: "PENDING_DISCOVERY";
+            KNOWN_MISSING: "KNOWN_MISSING";
+            NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+            DEFERRED: "DEFERRED";
+            RETIRED: "RETIRED";
+        }>;
+        expectedOwner: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        requiredFor: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        discoveryPolicy: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            hostMode: z.ZodDefault<z.ZodEnum<{
+                ALLOWLIST: "ALLOWLIST";
+                EVIDENCE_OBSERVED: "EVIDENCE_OBSERVED";
+            }>>;
+            allowedHosts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            forbiddenHostSuffixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            allowedPathPrefixes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>>;
+        notes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const sourceCoverageEntrySchema: z.ZodObject<{
+    sourceId: z.ZodString;
+    familyId: z.ZodString;
+    expectation: z.ZodEnum<{
+        REQUIRED: "REQUIRED";
+        OPTIONAL: "OPTIONAL";
+        CONDITIONAL: "CONDITIONAL";
+    }>;
+    declaredState: z.ZodEnum<{
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        CONFIGURED: "CONFIGURED";
+        PENDING_DISCOVERY: "PENDING_DISCOVERY";
+        KNOWN_MISSING: "KNOWN_MISSING";
+        NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+        DEFERRED: "DEFERRED";
+        RETIRED: "RETIRED";
+    }>;
+    coverageState: z.ZodEnum<{
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        PARTIAL: "PARTIAL";
+        ACQUIRED: "ACQUIRED";
+        BLOCKED: "BLOCKED";
+        PENDING_DISCOVERY: "PENDING_DISCOVERY";
+        KNOWN_MISSING: "KNOWN_MISSING";
+        NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+        DEFERRED: "DEFERRED";
+        RETIRED: "RETIRED";
+        CONFIGURED_UNOBSERVED: "CONFIGURED_UNOBSERVED";
+    }>;
+    configuredItemCount: z.ZodNumber;
+    observedItemCount: z.ZodNumber;
+    acquiredItemCount: z.ZodNumber;
+    blockedItemCount: z.ZodNumber;
+    accessControlledItemCount: z.ZodNumber;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+    blockers: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const sourceCoverageAssessmentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    assessedAt: z.ZodISODateTime;
+    complete: z.ZodBoolean;
+    requiredSourceCount: z.ZodNumber;
+    coveredRequiredSourceCount: z.ZodNumber;
+    entries: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        familyId: z.ZodString;
+        expectation: z.ZodEnum<{
+            REQUIRED: "REQUIRED";
+            OPTIONAL: "OPTIONAL";
+            CONDITIONAL: "CONDITIONAL";
+        }>;
+        declaredState: z.ZodEnum<{
+            ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+            CONFIGURED: "CONFIGURED";
+            PENDING_DISCOVERY: "PENDING_DISCOVERY";
+            KNOWN_MISSING: "KNOWN_MISSING";
+            NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+            DEFERRED: "DEFERRED";
+            RETIRED: "RETIRED";
+        }>;
+        coverageState: z.ZodEnum<{
+            ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+            PARTIAL: "PARTIAL";
+            ACQUIRED: "ACQUIRED";
+            BLOCKED: "BLOCKED";
+            PENDING_DISCOVERY: "PENDING_DISCOVERY";
+            KNOWN_MISSING: "KNOWN_MISSING";
+            NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+            DEFERRED: "DEFERRED";
+            RETIRED: "RETIRED";
+            CONFIGURED_UNOBSERVED: "CONFIGURED_UNOBSERVED";
+        }>;
+        configuredItemCount: z.ZodNumber;
+        observedItemCount: z.ZodNumber;
+        acquiredItemCount: z.ZodNumber;
+        blockedItemCount: z.ZodNumber;
+        accessControlledItemCount: z.ZodNumber;
+        evidenceRefs: z.ZodArray<z.ZodString>;
+        blockers: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    blockers: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const sourceGapStateSchema: z.ZodEnum<{
+    ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+    PENDING_DISCOVERY: "PENDING_DISCOVERY";
+    KNOWN_MISSING: "KNOWN_MISSING";
+    NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+    DEFERRED: "DEFERRED";
+}>;
+export declare const sourceGapSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    gapId: z.ZodString;
+    projectKey: z.ZodString;
+    sourceId: z.ZodString;
+    familyId: z.ZodString;
+    state: z.ZodEnum<{
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        PENDING_DISCOVERY: "PENDING_DISCOVERY";
+        KNOWN_MISSING: "KNOWN_MISSING";
+        NEED_AUTHORIZED_SOURCE: "NEED_AUTHORIZED_SOURCE";
+        DEFERRED: "DEFERRED";
+    }>;
+    access: z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>;
+    expectedOwner: z.ZodNullable<z.ZodString>;
+    reason: z.ZodString;
+    requiredFor: z.ZodArray<z.ZodString>;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+    recordedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const sourceDiscoveryProposalSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    proposalId: z.ZodString;
+    familyId: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    observedLinks: z.ZodArray<z.ZodObject<{
+        linkId: z.ZodString;
+        url: z.ZodURL;
+        locator: z.ZodString;
+        parentEvidenceRef: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    selectedLinkIds: z.ZodArray<z.ZodString>;
+    completeness: z.ZodObject<{
+        claim: z.ZodEnum<{
+            COMPLETE: "COMPLETE";
+            INCOMPLETE: "INCOMPLETE";
+        }>;
+        missing: z.ZodArray<z.ZodString>;
+        notes: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const sourceDiscoveryValidationSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    proposalId: z.ZodString;
+    familyId: z.ZodString;
+    proposalHash: z.ZodString;
+    valid: z.ZodBoolean;
+    selectedSources: z.ZodArray<z.ZodObject<{
+        linkId: z.ZodString;
+        url: z.ZodURL;
+        parentEvidenceRef: z.ZodString;
+    }, z.core.$strict>>;
+    completeness: z.ZodObject<{
+        claim: z.ZodEnum<{
+            COMPLETE: "COMPLETE";
+            INCOMPLETE: "INCOMPLETE";
+        }>;
+        missing: z.ZodArray<z.ZodString>;
+        notes: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+    errors: z.ZodArray<z.ZodString>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const sourceDiscoveryReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    proposalId: z.ZodString;
+    familyId: z.ZodString;
+    proposalHash: z.ZodString;
+    state: z.ZodEnum<{
+        COMPLETE: "COMPLETE";
+        REVIEWED_PARTIAL: "REVIEWED_PARTIAL";
+    }>;
+    proposalRef: z.ZodString;
+    reviewRef: z.ZodString;
+    reviewedAt: z.ZodISODateTime;
+    selectedSources: z.ZodArray<z.ZodObject<{
+        linkId: z.ZodString;
+        url: z.ZodURL;
+        parentEvidenceRef: z.ZodString;
+    }, z.core.$strict>>;
+    completeness: z.ZodObject<{
+        claim: z.ZodEnum<{
+            COMPLETE: "COMPLETE";
+            INCOMPLETE: "INCOMPLETE";
+        }>;
+        missing: z.ZodArray<z.ZodString>;
+        notes: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+    configMutationPerformed: z.ZodLiteral<false>;
+}, z.core.$strict>;
+export type SourceDiscoveryPolicy = z.infer<typeof sourceDiscoveryPolicySchema>;
+export type SourceExpectation = z.infer<typeof sourceExpectationSchema>;
+export type SourceDeclaredState = z.infer<typeof sourceDeclaredStateSchema>;
+export type SourceCoverageState = z.infer<typeof sourceCoverageStateSchema>;
+export type SourceUniverseEntry = z.infer<typeof sourceUniverseEntrySchema>;
+export type SourceUniverse = z.infer<typeof sourceUniverseSchema>;
+export type SourceCoverageEntry = z.infer<typeof sourceCoverageEntrySchema>;
+export type SourceCoverageAssessment = z.infer<typeof sourceCoverageAssessmentSchema>;
+export type SourceGap = z.infer<typeof sourceGapSchema>;
+export type SourceDiscoveryProposal = z.infer<typeof sourceDiscoveryProposalSchema>;
+export type SourceDiscoveryValidation = z.infer<typeof sourceDiscoveryValidationSchema>;
+export declare const sourceAdmissionMatchSchema: z.ZodObject<{
+    url: z.ZodURL;
+    status: z.ZodEnum<{
+        BLOCKED: "BLOCKED";
+        ADMITTED: "ADMITTED";
+        MISSING: "MISSING";
+        DUPLICATE: "DUPLICATE";
+    }>;
+    universeSourceId: z.ZodNullable<z.ZodString>;
+    acquisitionSourceId: z.ZodNullable<z.ZodString>;
+    concreteSourceId: z.ZodNullable<z.ZodString>;
+    issues: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const sourceAdmissionAssessmentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    projectKey: z.ZodString;
+    familyId: z.ZodString;
+    state: z.ZodEnum<{
+        BLOCKED: "BLOCKED";
+        ADMITTED: "ADMITTED";
+    }>;
+    selectedSourceCount: z.ZodNumber;
+    matches: z.ZodArray<z.ZodObject<{
+        url: z.ZodURL;
+        status: z.ZodEnum<{
+            BLOCKED: "BLOCKED";
+            ADMITTED: "ADMITTED";
+            MISSING: "MISSING";
+            DUPLICATE: "DUPLICATE";
+        }>;
+        universeSourceId: z.ZodNullable<z.ZodString>;
+        acquisitionSourceId: z.ZodNullable<z.ZodString>;
+        concreteSourceId: z.ZodNullable<z.ZodString>;
+        issues: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    blockers: z.ZodArray<z.ZodString>;
+    configMutationPerformed: z.ZodLiteral<false>;
+}, z.core.$strict>;
+export type SourceDiscoveryReceipt = z.infer<typeof sourceDiscoveryReceiptSchema>;
+export type SourceAdmissionMatch = z.infer<typeof sourceAdmissionMatchSchema>;
+export type SourceAdmissionAssessment = z.infer<typeof sourceAdmissionAssessmentSchema>;

package/dist/types/contracts/source.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+export declare const sourceKindSchema: z.ZodEnum<{
+    MANUAL: "MANUAL";
+    FILE: "FILE";
+    WEB: "WEB";
+    API: "API";
+    REPOSITORY: "REPOSITORY";
+    FEED: "FEED";
+    SOCIAL: "SOCIAL";
+    BROWSER: "BROWSER";
+    OTHER: "OTHER";
+}>;
+export declare const sourceDefinitionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    sourceId: z.ZodString;
+    projectKey: z.ZodOptional<z.ZodString>;
+    kind: z.ZodEnum<{
+        MANUAL: "MANUAL";
+        FILE: "FILE";
+        WEB: "WEB";
+        API: "API";
+        REPOSITORY: "REPOSITORY";
+        FEED: "FEED";
+        SOCIAL: "SOCIAL";
+        BROWSER: "BROWSER";
+        OTHER: "OTHER";
+    }>;
+    authority: z.ZodString;
+    access: z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>;
+    canonicalUri: z.ZodOptional<z.ZodString>;
+    refreshPolicy: z.ZodString;
+    enabled: z.ZodBoolean;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const collectorDefinitionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    collectorId: z.ZodString;
+    version: z.ZodString;
+    supportedSourceKinds: z.ZodArray<z.ZodEnum<{
+        MANUAL: "MANUAL";
+        FILE: "FILE";
+        WEB: "WEB";
+        API: "API";
+        REPOSITORY: "REPOSITORY";
+        FEED: "FEED";
+        SOCIAL: "SOCIAL";
+        BROWSER: "BROWSER";
+        OTHER: "OTHER";
+    }>>;
+    capabilities: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type SourceKind = z.infer<typeof sourceKindSchema>;
+export type SourceDefinition = z.infer<typeof sourceDefinitionSchema>;
+export type CollectorDefinition = z.infer<typeof collectorDefinitionSchema>;

package/dist/types/contracts/tenant-budget.d.ts

@@ -0,0 +1,59 @@
+/** Host-authored admission accounting, independent of business authorization and receipt schemas. */
+import { z } from 'zod';
+export declare const tenantBudgetPolicySchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    maxInFlight: z.ZodNumber;
+    maxWorkUnits: z.ZodNumber;
+    maxRuntimeMs: z.ZodNumber;
+    weight: z.ZodNumber;
+    paused: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const tenantBudgetConfigSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    windowSeconds: z.ZodNumber;
+    maxInFlight: z.ZodNumber;
+    maxWaitRounds: z.ZodNumber;
+    tenants: z.ZodArray<z.ZodObject<{
+        tenantId: z.ZodString;
+        maxInFlight: z.ZodNumber;
+        maxWorkUnits: z.ZodNumber;
+        maxRuntimeMs: z.ZodNumber;
+        weight: z.ZodNumber;
+        paused: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const tenantBudgetCandidateSchema: z.ZodObject<{
+    key: z.ZodString;
+    tenantId: z.ZodString;
+    workUnits: z.ZodNumber;
+    runtimeMs: z.ZodNumber;
+}, z.core.$strict>;
+export declare const tenantBudgetReservationSchema: z.ZodObject<{
+    key: z.ZodString;
+    tenantId: z.ZodString;
+    workUnits: z.ZodNumber;
+    runtimeMs: z.ZodNumber;
+    admissionId: z.ZodString;
+    nodeId: z.ZodString;
+    startedAt: z.ZodISODateTime;
+    expiresAt: z.ZodISODateTime;
+    windowStart: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const tenantBudgetReasonSchema: z.ZodEnum<{
+    READY: "READY";
+    TENANT_UNCONFIGURED: "TENANT_UNCONFIGURED";
+    PAUSED: "PAUSED";
+    HOST_IN_FLIGHT: "HOST_IN_FLIGHT";
+    TENANT_IN_FLIGHT: "TENANT_IN_FLIGHT";
+    WORK_BUDGET: "WORK_BUDGET";
+    TIME_BUDGET: "TIME_BUDGET";
+    WORK_ACTIVE: "WORK_ACTIVE";
+}>;
+export type TenantBudgetConfig = z.infer<typeof tenantBudgetConfigSchema>;
+export type TenantBudgetCandidate = z.infer<typeof tenantBudgetCandidateSchema>;
+export type TenantBudgetReservation = z.infer<typeof tenantBudgetReservationSchema>;
+/** 两小时是整个准入的硬上限；短任务保留结算余量，合法的上限任务不因此被排除。 */
+export declare function tenantLegacyAdmissionRuntimeMs(timeoutSeconds: number): number;
+export type TenantBudgetReason = z.infer<typeof tenantBudgetReasonSchema>;
+export declare function tenantCollectionAdmissionKey(tenantId: string, batchRef: string): string;
+export declare function tenantLegacyAdmissionKey(tenantId: string, workloadId: string): string;