@nexusclawhq/cli 0.2.1

package/dist/nexus-cli/src/services/api-client.d.ts

@@ -0,0 +1,1097 @@
+import type { AiAuthoringContextLockV2, AiAuthoringContextSnapshotV2, AiAuthoringContextVerificationV1, AiContextSigningKeySetV1, DescribeAiAuthoringContextRequestV2, SignAiAuthoringContextLockRequestV2, ValidateExecutablePackageArtifactInputV1, ValidateExecutablePackageArtifactResultV1, VerifyAiAuthoringContextFreshnessRequestV2, WorkforceBundleSourceLockV1 } from '@nexusclaw/shared';
+export interface CreateExecutablePackageUploadSessionInput {
+    readonly schemaVersion: 'nexusclaw.create-executable-package-upload-session-input/v1';
+    readonly targetWorkspaceId: string;
+    readonly archiveFormat: 'zip-store-v1';
+    readonly archiveDigest: `sha256:${string}`;
+    readonly packageDigest: `sha256:${string}`;
+    readonly archiveSizeBytes: number;
+    readonly fileCount: number;
+    readonly declaredSurfaces: ReadonlyArray<'config' | 'code' | 'flow' | 'employee'>;
+}
+export interface ExecutablePackageUploadSession {
+    readonly uploadSessionId: string;
+    readonly expiresAt: string;
+    readonly uploadUrl: string;
+    readonly method: 'PUT';
+    readonly requiredHeaderNames: readonly string[];
+}
+export interface WorkforceBundleArtifactOperationInput {
+    readonly schemaVersion: string;
+    readonly targetWorkspaceId: string;
+    readonly stagedArtifactId: string;
+    readonly expectedArchiveDigest: `sha256:${string}`;
+    readonly expectedPackageDigest: `sha256:${string}`;
+    readonly contextManifestContentDigest: `sha256:${string}`;
+    readonly runtimeBindingsDigest: `sha256:${string}`;
+    readonly expectedPortableBundleDigest: `sha256:${string}`;
+}
+export type WorkforceBundleLockResult = WorkforceBundleSourceLockV1;
+export interface WorkforceBundlePlanResult {
+    readonly schemaVersion: 'nexusclaw.executable-workforce-bundle-plan/v1';
+    readonly planDigest: `sha256:${string}`;
+    readonly releaseItemSetDigest: `sha256:${string}`;
+    readonly sourceLockDigest: `sha256:${string}`;
+    readonly plannedItems: ReadonlyArray<{
+        readonly itemKind: string;
+        readonly canonicalKey: string;
+        readonly checksum: `sha256:${string}`;
+        readonly descriptorHash: `sha256:${string}` | null;
+    }>;
+    readonly headAtPlan: {
+        readonly activeReleaseSetId: string | null;
+        readonly generation: number;
+    };
+    readonly lock: WorkforceBundleSourceLockV1;
+}
+export interface CandidateStageReceiptResult {
+    readonly schemaVersion: 'nexusclaw.candidate-stage-receipt/v1';
+    readonly candidateReleaseSetId: string;
+    readonly agentApiName: string;
+    readonly eligibilityStatus: 'staged';
+    readonly sourceLockDigest: `sha256:${string}`;
+    readonly releaseItemSetDigest: `sha256:${string}`;
+    readonly materializedItemRefsDigest: `sha256:${string}`;
+    readonly releaseEnvelopeDigest: null;
+    readonly previousReleaseSetId: string | null;
+    readonly headAtStage: {
+        readonly activeReleaseSetId: string | null;
+        readonly generation: number;
+    };
+    readonly planDigest: `sha256:${string}`;
+}
+export type WorkforceCandidateSelector = {
+    readonly kind: 'action';
+    readonly exportId: string;
+    readonly suites: readonly string[];
+} | {
+    readonly kind: 'flow';
+    readonly flowApiName: string;
+    readonly suites: readonly string[];
+} | {
+    readonly kind: 'employee';
+    readonly suites: readonly string[];
+};
+export interface WorkforceCandidateReleaseItem {
+    readonly itemKind: string;
+    readonly selectorKey: string;
+}
+export interface CandidateTestRunResult {
+    readonly evidenceRunId: string;
+    readonly evidenceRunDigest: `sha256:${string}`;
+    readonly passed: boolean;
+    readonly refs: ReadonlyArray<{
+        readonly kind: string;
+        readonly evidenceId: string;
+        readonly digest: `sha256:${string}`;
+        readonly producer: string;
+        readonly createdAt: string;
+    }>;
+    readonly isolationBindingId: string;
+    readonly isolationSnapshotHash: `sha256:${string}`;
+    readonly resetReceiptId: string;
+    readonly resetReceiptDigest: `sha256:${string}`;
+    readonly newAuthorizationGeneration: number;
+}
+export interface WorkforceReleaseGateReceipt {
+    readonly schemaVersion: string;
+    readonly approvalId: string;
+    readonly candidateReleaseSetId: string;
+    readonly evidenceRunIds: readonly string[];
+    readonly expectedSourceLockDigest: `sha256:${string}`;
+    readonly expectedReleaseItemSetDigest: `sha256:${string}`;
+    readonly expectedMaterializedItemRefsDigest: `sha256:${string}`;
+    readonly governanceContextDigest: `sha256:${string}`;
+    readonly decision: string;
+    readonly decisionVersion: number;
+    readonly expiresAt: string;
+    readonly consumedAt: string | null;
+    readonly receiptDigest: `sha256:${string}`;
+}
+export interface WorkforceReleaseTransitionResult {
+    readonly schemaVersion: string;
+    readonly operation: 'promote' | 'rollback';
+    readonly beforeReleaseSetId: string | null;
+    readonly afterReleaseSetId: string | null;
+    readonly beforeGeneration: number;
+    readonly afterGeneration: number;
+    readonly receiptId: string;
+    readonly outboxId: string;
+    readonly alreadyApplied: boolean;
+}
+export interface SealedExecutablePackageArtifact {
+    readonly stagedArtifactId: string;
+    readonly status: 'sealed';
+    readonly archiveDigest: `sha256:${string}`;
+    readonly packageDigest: `sha256:${string}`;
+    readonly sizeBytes: number;
+    readonly fileCount: number;
+    readonly declaredSurfaces: ReadonlyArray<'config' | 'code' | 'flow' | 'employee'>;
+    readonly sealedAt: string;
+    readonly expiresAt: string;
+}
+export interface ApiResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    errors?: string[];
+}
+export interface DeployResult {
+    jobId: string;
+    status: string;
+    message?: string;
+}
+export interface DeployStatus {
+    jobId: string;
+    status: 'pending' | 'running' | 'success' | 'failed';
+    progress?: number;
+    message?: string;
+    errors?: string[];
+}
+export interface ValidateResult {
+    success: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export interface ValidationReportIssue {
+    code: string;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    category: string;
+    message: string;
+    recommendation?: string;
+    path?: string;
+    line?: number;
+    column?: number;
+    componentId?: string;
+    componentName?: string;
+    componentType?: string;
+}
+export interface ValidationReport {
+    schemaVersion: 'deployment-validation-report/v1';
+    operation: string;
+    success: boolean;
+    generatedAt: string;
+    workspaceId?: string;
+    targetEnvironment?: string;
+    errors: ValidationReportIssue[];
+    warnings: ValidationReportIssue[];
+    suggestions: string[];
+    affectedComponents: Array<Record<string, unknown>>;
+    compatibility?: Record<string, unknown>;
+    summary: {
+        errorCount: number;
+        warningCount: number;
+        suggestionCount: number;
+        affectedComponentCount: number;
+    };
+    metadata?: Record<string, unknown>;
+}
+export interface ManagedChangeSet {
+    id: string;
+    workspaceId: string;
+    name: string;
+    description?: string;
+    sourceEnvironment: string;
+    targetEnvironment: string;
+    status: string;
+    approvalRequired?: boolean;
+    approvalStatus?: string;
+    validationMessage?: string;
+    createdBy?: string;
+    createdAt: string;
+    updatedAt: string;
+    validatedAt?: string;
+    deployedAt?: string;
+    rolledBackAt?: string;
+    metadata?: Record<string, unknown> | null;
+    components?: Array<Record<string, unknown>>;
+}
+export interface RetrieveResult {
+    downloadUrl: string;
+    filename: string;
+    size: number;
+}
+export interface RuntimeSourceFile {
+    path: string;
+    content: string;
+}
+export interface RuntimeRenderedFile extends RuntimeSourceFile {
+    hash: string;
+}
+export interface RuntimeValidationResult {
+    validation: {
+        valid: boolean;
+        summary: string[];
+    };
+}
+export interface RuntimePlanResult extends RuntimeValidationResult {
+    dryRun?: boolean;
+    destructiveSync?: boolean;
+    diff: {
+        humanSummary: string[];
+        summary: {
+            objects: {
+                created: number;
+                updated: number;
+                deleted: number;
+            };
+            fields: {
+                created: number;
+                updated: number;
+                deleted: number;
+            };
+        };
+    };
+}
+export interface RuntimeApplyResult {
+    applied: boolean;
+    dryRun: boolean;
+    destructiveSync: boolean;
+    beforeRevision?: string;
+    afterRevision?: string;
+    plan: RuntimePlanResult;
+}
+export interface RuntimeExportResult {
+    snapshot: unknown;
+    files: RuntimeRenderedFile[];
+}
+export interface MetadataPackageDependency {
+    name: string;
+    versionRange: string;
+    optional?: boolean;
+}
+export interface MetadataKindSupportEntry {
+    kind: string;
+    executionMode: string;
+    notes?: string;
+}
+export interface CodeKindSupportEntry {
+    kind: 'function' | 'trigger' | 'library' | 'test' | 'ui-component';
+    executionMode: 'sandboxed-runtime' | 'binding-only' | 'build-input' | 'workspace-only';
+    notes?: string;
+}
+export interface MetadataPackageManifest {
+    schemaVersion: 'v1';
+    name: string;
+    packageType: string;
+    packageClass: 'metadata' | 'seed-data' | 'asset' | 'code-extension';
+    description: string;
+    version: string;
+    dependencies: MetadataPackageDependency[];
+    compatibleCoreVersion: string;
+    installOrder: number;
+    includedMetadataKinds: string[];
+    includedSeedKinds: string[];
+    includedCodeKinds?: Array<'function' | 'trigger' | 'library' | 'test' | 'ui-component'>;
+    visibility: string;
+    releaseChannel: string;
+    kindSupport: MetadataKindSupportEntry[];
+    codeKindSupport?: CodeKindSupportEntry[];
+    runtimeProviderRequirement?: 'hardened-isolate' | 'nexusclaw-verified-isolate-v1';
+    codeExtensionGovernance?: {
+        contractVersion: 'code-extension-governance/v1';
+        runtimeApiVersion: string;
+    } | {
+        contractVersion: 'code-extension-governance/v2';
+        runtimeApiVersion: 'runtime/v2';
+    };
+    agentToolCatalogPath?: string;
+    trialEvidence?: {
+        extensionRuntimeLogPath: string;
+        dependencyReportPath: string;
+        failedExtensionEvidencePath: string;
+        debugAttributionPath?: string;
+        rollbackEvidencePath?: string;
+        trackedExtensions?: Array<{
+            packageName: string;
+            extensionId: string;
+            kind: 'function' | 'trigger';
+        }>;
+    };
+    executableArtifacts?: Array<{
+        extensionId?: string;
+        apiName: string;
+        kind: 'function' | 'trigger';
+        sourcePath: string;
+        dependsOn?: string[];
+        functionType?: 'ACTION';
+        entrypoint?: 'default';
+        actionContractVersion?: 'nexus-code-action/v1';
+        runtimeApiVersion?: 'runtime/v2';
+    }>;
+}
+export interface ExtensionGovernanceCheckedExtension {
+    extensionId: string;
+    kind: 'function' | 'trigger';
+    apiName: string;
+    sourcePath: string;
+    dependsOn: string[];
+    errors: string[];
+    warnings: string[];
+}
+export interface ExtensionGovernanceValidationResult {
+    schemaVersion: 'code-extension-governance-validation/v1';
+    status: 'passed' | 'warning' | 'failed';
+    packageName: string;
+    packageVersion: string;
+    contractVersion: string | null;
+    runtimeApiVersion: string | null;
+    checkedExtensions: ExtensionGovernanceCheckedExtension[];
+    errors: string[];
+    warnings: string[];
+    artifactRefs: string[];
+    evidenceRefs: string[];
+    comparedUpgradeFields: string[];
+    attributionSummary: Array<'extension' | 'runtime' | 'dependency' | 'config'>;
+}
+export interface MetadataPackageInstallPlanResult {
+    packageNames: string[];
+    orderedSteps: Array<{
+        phase: string;
+        packageName: string;
+        executionTrack?: string;
+        rollbackHint?: string;
+    }>;
+    warnings: string[];
+    summary?: string[];
+    dependencies?: {
+        missingDependencies: string[];
+        circularDependencies?: string[];
+        versionConflicts?: string[];
+        coreVersionConflicts?: string[];
+        conflictSummary?: string[];
+    };
+}
+export interface MetadataPackageInstallResult {
+    packageName: string;
+    status: string;
+    appliedMetadataKinds: string[];
+    appliedSeedKinds: string[];
+    warnings: string[];
+    executionTrack?: string;
+    installedStateId?: string;
+    details?: Record<string, unknown>;
+}
+export interface EmployeePackageInstallResult {
+    status: 'installed' | 'updated' | 'rejected';
+    agentId?: string;
+    agentStatus?: 'draft' | 'active' | 'archived';
+    activated: boolean;
+    guardrails: {
+        upserted: number;
+    };
+    knowledge: {
+        upserted: number;
+        embedded: number;
+        skippedEmbeddings: number;
+    };
+    evalCases: {
+        upserted: number;
+        ran: number;
+        skippedMutating: number;
+    };
+    gate: {
+        passRate: number | null;
+        minPassRate: number;
+        baselinePassRate: number | null;
+        regressed: boolean;
+        passed: boolean;
+        suiteRunId?: string;
+        casesRun: number;
+        failures: Array<{
+            testCaseId: string;
+            name: string;
+            failureReason?: string;
+        }>;
+    } | null;
+    errors: string[];
+    deploymentReportId?: string;
+    gateReportId?: string;
+    auditId?: string;
+}
+export interface RuntimeDemoPreflightReport {
+    id: string;
+    workspaceId: string;
+    actor?: string | null;
+    overallStatus: 'REHEARSAL_READY' | 'REHEARSAL_BLOCKED';
+    coreVersion?: string | null;
+    cliVersion?: string | null;
+    frontendImageSha?: string | null;
+    mobileImageSha?: string | null;
+    backendImageSha?: string | null;
+    cliImageSha?: string | null;
+    metadataInstallIds: string[];
+    businessDataInstallIds: string[];
+    deploymentReportId?: string | null;
+    gateReportId?: string | null;
+    auditId?: string | null;
+    agentId?: string | null;
+    checks: Array<{
+        code: string;
+        status: 'passed' | 'failed' | 'missing';
+        evidence?: Record<string, unknown> | null;
+        reason?: string | null;
+    }>;
+    blockers: string[];
+    createdAt: string;
+}
+export interface EmployeeDeploymentReportRecord {
+    id: string;
+    workspaceId: string;
+    agentId: string;
+    gateReportId?: string | null;
+    auditId?: string | null;
+    packageName: string;
+    packageVersion: string;
+    status: 'installed' | 'updated' | 'rejected';
+    activationStatus: 'draft' | 'active' | 'archived';
+    activated: boolean;
+    gatePassed: boolean;
+    gateFailureReason?: string | null;
+    coreVersion?: string | null;
+    cliVersion?: string | null;
+    errors: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface InstallationContractRecord {
+    installationId: string;
+    workspaceId: string;
+    packageName?: string;
+    version?: string;
+    contractName?: string;
+    contractVersion?: string;
+    compatibleCoreSha: string | null;
+    auditId?: string | null;
+    sourceUri?: string | null;
+    installedAt?: string | null;
+    createdAt?: string;
+    summary?: Record<string, unknown> | null;
+}
+export interface MetadataPackageUpgradeResult {
+    packageName: string;
+    status: string;
+    warnings: string[];
+    destructiveChanges?: string[];
+    installResult?: MetadataPackageInstallResult;
+}
+export interface MetadataPackageRollbackResult {
+    packageName: string;
+    status: string;
+    warnings: string[];
+    restoredStateId?: string;
+    snapshotTimestamp?: string;
+    restoredVersion?: string | null;
+    details?: Record<string, unknown>;
+}
+export interface MetadataPackageUninstallResult {
+    packageName: string;
+    status: string;
+    warnings: string[];
+    blockedBy?: string[];
+}
+export interface InstalledMetadataPackageRecord {
+    id: string;
+    workspaceId: string;
+    packageName: string;
+    version: string;
+    packageDigest?: string | null;
+    installSource: string;
+    status: string;
+    installedAt: string;
+    updatedAt: string;
+    manifest: MetadataPackageManifest;
+    ownedCodeArtifacts?: Array<Record<string, unknown>> | null;
+    runtimeProviderRequirement?: string | null;
+}
+export interface MetadataPackageInstallHistoryRecord {
+    id: string;
+    workspaceId: string;
+    packageName: string;
+    version: string;
+    action: string;
+    status: string;
+    installSource: string;
+    sourceUri?: string | null;
+    manifest: MetadataPackageManifest;
+    details?: Record<string, unknown> | null;
+    sourceStateId?: string | null;
+    targetStateId?: string | null;
+    rollbackDetails?: Record<string, unknown> | null;
+    createdAt: string;
+}
+export interface PromotionRecord {
+    id: string;
+    packageName: string;
+    version: string;
+    sourceChannel: string;
+    targetChannel: string;
+    promotedBy: string;
+    promotedAt: string;
+    approvalStatus: 'pending' | 'approved' | 'rejected';
+    approvedBy?: string | null;
+    approvedAt?: string | null;
+    rejectionReason?: string | null;
+    metadata?: Record<string, unknown> | null;
+}
+export interface RolloutStatusResult {
+    packageName: string;
+    version: string;
+    channel: string;
+    percentage: number;
+    includedWorkspaceCount: number;
+    totalEligibleWorkspaces: number;
+    includedWorkspaceIds: string[];
+    rollout: Record<string, unknown>;
+}
+export interface ChannelEntitlementRecord {
+    id: string;
+    workspaceId: string;
+    channel: string;
+    grantedBy: string;
+    grantedAt: string;
+    revokedBy?: string | null;
+    revokedAt?: string | null;
+    status: 'active' | 'revoked';
+    metadata?: Record<string, unknown> | null;
+}
+export interface ChannelPolicyResult {
+    path: string;
+    policy: Record<string, unknown>;
+}
+export interface CodeEnvironmentPromotionPackageInput {
+    manifest: MetadataPackageManifest;
+    packageDirectory?: string;
+    archivePath?: string;
+    serializerChangeSetId?: string;
+    sourceUri?: string;
+}
+export interface CodeEnvironmentPromotionPlanResult {
+    valid: boolean;
+    targetWorkspaceId: string;
+    sourceEnvironment?: string | null;
+    runtimePolicyRef?: string | null;
+    runtimeProviderId: string;
+    allowPartialFailure: boolean;
+    warnings: string[];
+    errors: string[];
+    packages: Array<{
+        packageName: string;
+        version: string;
+        packageClass?: string;
+        action: 'install' | 'upgrade' | 'noop';
+        valid: boolean;
+        warnings: string[];
+        errors: string[];
+        executionTrack?: string;
+        installedVersion?: string | null;
+        runtimeProviderRequirement?: string | null;
+    }>;
+    drift: {
+        missingPackages: string[];
+        versionMismatches: string[];
+        extraCodePackages: string[];
+    };
+}
+export interface CodeEnvironmentPromotionResult {
+    success: boolean;
+    targetWorkspaceId: string;
+    sourceEnvironment?: string | null;
+    runtimePolicyRef?: string | null;
+    warnings: string[];
+    errors: string[];
+    precheck: CodeEnvironmentPromotionPlanResult;
+    appliedPackages: Array<{
+        packageName: string;
+        version: string;
+        action: 'install' | 'upgrade' | 'noop';
+        status: string;
+        warnings: string[];
+        executionTrack?: string;
+        installedStateId?: string;
+        deploymentHistoryId?: string | null;
+    }>;
+    rollbackResults: Array<{
+        packageName: string;
+        status: string;
+        warnings: string[];
+        details?: Record<string, unknown>;
+    }>;
+}
+export interface SourceMemberRecord {
+    id: string;
+    componentType: string;
+    componentId: string;
+    componentName: string;
+    changeType: string;
+    changeSource: string;
+    changedAt: string;
+}
+export interface SourceStatusFileRecord {
+    path: string;
+    hash: string;
+    componentKey?: string;
+    baselineHash?: string | null;
+    track?: 'metadata-runtime' | 'code-extension';
+}
+export interface SourceDriftResult {
+    baselineAvailable: boolean;
+    baselineSource?: string | null;
+    diff?: Record<string, unknown> | null;
+    totalChanges: number;
+    humanSummary: string[];
+}
+export interface SourceStatusResult {
+    remoteRevision: string;
+    remoteHash?: string;
+    baselineRevision?: string | null;
+    baselineHash?: string | null;
+    baselineSource?: string | null;
+    baselineAvailable: boolean;
+    files: SourceStatusFileRecord[];
+    baselineFiles: SourceStatusFileRecord[];
+    drift: SourceDriftResult;
+    changedComponentCount: number;
+    tracking?: Record<string, unknown> | null;
+}
+export interface SourceFilesResult {
+    remoteRevision: string;
+    files: Array<SourceStatusFileRecord & {
+        content: string;
+    }>;
+}
+export interface PushSourceFileInput {
+    path: string;
+    content?: string | null;
+    deleted?: boolean;
+}
+export interface PushSourceResult {
+    success: boolean;
+    count: number;
+    dryRun: boolean;
+    beforeRevision?: string;
+    afterRevision?: string;
+    plan?: {
+        humanSummary: string[];
+        summary: Record<string, unknown>;
+    };
+}
+export interface SourceBaselineRebuildResult {
+    success: boolean;
+    baselineAvailable: boolean;
+    baselineRevision?: string | null;
+    baselineSource?: string | null;
+    filesCount: number;
+    warnings: string[];
+}
+export interface RuntimeComposerPackageRef {
+    packageName: string;
+    version?: string;
+    packageType: string;
+    source?: 'local' | 'registry' | 'workspace';
+}
+export interface RuntimeComposerInput {
+    tenantId: string;
+    baseline: RuntimeComposerPackageRef;
+    genericOverlay?: RuntimeComposerPackageRef | null;
+    industryOverlay?: RuntimeComposerPackageRef | null;
+    extensionPacks: RuntimeComposerPackageRef[];
+    demoPack?: RuntimeComposerPackageRef | null;
+    environmentProfile?: RuntimeComposerPackageRef | null;
+}
+export interface RuntimeComposerPreviewResult {
+    plan: {
+        tenantId: string;
+        orderedPackages: RuntimeComposerPackageRef[];
+        warnings: string[];
+    };
+    effective: {
+        warnings: string[];
+        destructiveSummary: string[];
+        diff: {
+            humanSummary: string[];
+            changes: Array<Record<string, unknown>>;
+        };
+        validation: {
+            valid: boolean;
+            summary: string[];
+        };
+    };
+    fromCache: boolean;
+    materializedSnapshotId?: string;
+}
+export interface DeploymentRollbackResult {
+    id: string;
+    result?: string;
+    errorMessage?: string | null;
+}
+export interface PromoteSandboxInput {
+    sandboxId: string;
+    promoteFrontend: boolean;
+    promoteBackend: boolean;
+    reason: string;
+}
+export interface SandboxPromotionPrecheckResult {
+    canPromote: boolean;
+    warnings: string[];
+    errors: string[];
+    frontendDiff: {
+        from: string;
+        to: string;
+        changes: string[];
+    };
+    backendDiff: {
+        from: string;
+        to: string;
+        changes: string[];
+    };
+}
+export interface GraphQLApiErrorDetail {
+    message: string;
+    code?: string;
+    path?: ReadonlyArray<string | number> | string;
+    ruleId?: string;
+    retryable?: boolean;
+}
+export declare class GraphQLApiError extends Error {
+    readonly errors: ReadonlyArray<GraphQLApiErrorDetail>;
+    constructor(errors: ReadonlyArray<GraphQLApiErrorDetail>);
+}
+export declare class ApiClient {
+    private baseUrl;
+    private token?;
+    private orgAlias?;
+    private requestTimeoutMs;
+    private readonly tokenFromEnvironment;
+    constructor(baseUrl?: string, token?: string, orgAlias?: string, requestTimeoutMs?: number);
+    ensureValidToken(): Promise<void>;
+    private refreshOAuthTokenPair;
+    private getHeaders;
+    private request;
+    private putRawBytes;
+    get<T>(endpoint: string): Promise<ApiResponse<T>>;
+    post<T>(endpoint: string, body?: unknown): Promise<ApiResponse<T>>;
+    put<T>(endpoint: string, body?: unknown): Promise<ApiResponse<T>>;
+    delete<T>(endpoint: string): Promise<ApiResponse<T>>;
+    graphql<T>(query: string, variables?: Record<string, unknown>): Promise<T>;
+    getAiContextSigningKeys(): Promise<AiContextSigningKeySetV1>;
+    createExecutablePackageUploadSession(input: CreateExecutablePackageUploadSessionInput, idempotencyKey: string): Promise<ExecutablePackageUploadSession>;
+    uploadExecutablePackageArtifact(input: {
+        readonly uploadUrl: string;
+        readonly bytes: Uint8Array;
+        readonly archiveDigest: `sha256:${string}`;
+        readonly packageDigest: `sha256:${string}`;
+        readonly idempotencyKey: string;
+    }): Promise<SealedExecutablePackageArtifact>;
+    resolveWorkforceBundleLock(input: WorkforceBundleArtifactOperationInput): Promise<WorkforceBundleLockResult>;
+    planExecutableWorkforceBundle(input: WorkforceBundleArtifactOperationInput & {
+        readonly expectedActiveReleaseSetId: string;
+        readonly expectedGeneration: number;
+    }): Promise<WorkforceBundlePlanResult>;
+    stageExecutableWorkforceBundle(input: WorkforceBundleArtifactOperationInput & {
+        readonly expectedActiveReleaseSetId: string;
+        readonly expectedGeneration: number;
+        readonly planDigest: `sha256:${string}`;
+        readonly authoringContext: VerifyAiAuthoringContextFreshnessRequestV2;
+    }, idempotencyKey: string): Promise<CandidateStageReceiptResult>;
+    runWorkforceCandidateTests(input: {
+        readonly targetWorkspaceId: string;
+        readonly candidateReleaseSetId: string;
+        readonly selectors: readonly WorkforceCandidateSelector[];
+        readonly expectedSourceLockDigest: `sha256:${string}`;
+        readonly expectedReleaseItemSetDigest: `sha256:${string}`;
+        readonly expectedMaterializedItemRefsDigest: `sha256:${string}`;
+    }, idempotencyKey: string): Promise<CandidateTestRunResult>;
+    getWorkforceCandidateReleaseItems(input: {
+        readonly targetWorkspaceId: string;
+        readonly candidateReleaseSetId: string;
+    }): Promise<readonly WorkforceCandidateReleaseItem[]>;
+    requestWorkforceReleaseApproval(input: {
+        readonly targetWorkspaceId: string;
+        readonly candidateReleaseSetId: string;
+        readonly evidenceRunIds: readonly string[];
+        readonly expectedSourceLockDigest: `sha256:${string}`;
+        readonly expectedReleaseItemSetDigest: `sha256:${string}`;
+        readonly expectedMaterializedItemRefsDigest: `sha256:${string}`;
+    }, idempotencyKey: string): Promise<WorkforceReleaseGateReceipt>;
+    getWorkforceReleaseApprovalStatus(input: {
+        readonly targetWorkspaceId: string;
+        readonly candidateReleaseSetId: string;
+        readonly approvalId: string;
+    }): Promise<WorkforceReleaseGateReceipt>;
+    evaluateAndSealWorkforceCandidateRelease(input: {
+        readonly targetWorkspaceId: string;
+        readonly candidateReleaseSetId: string;
+        readonly evidenceRunIds: readonly string[];
+        readonly expectedSourceLockDigest: `sha256:${string}`;
+        readonly expectedReleaseItemSetDigest: `sha256:${string}`;
+        readonly expectedMaterializedItemRefsDigest: `sha256:${string}`;
+        readonly approvalId: string;
+    }, idempotencyKey: string): Promise<{
+        releaseSetId: string;
+        evidenceId: string;
+        eligibilityStatus: 'eligible' | 'rejected';
+        releaseEnvelopeDigest: `sha256:${string}`;
+        alreadySealed: boolean;
+    }>;
+    promoteWorkforceRelease(input: Record<string, unknown>, idempotencyKey: string): Promise<WorkforceReleaseTransitionResult>;
+    rollbackWorkforceRelease(input: Record<string, unknown>, idempotencyKey: string): Promise<WorkforceReleaseTransitionResult>;
+    revokeExecutableToolExport(input: Record<string, unknown>, idempotencyKey: string): Promise<Record<string, unknown>>;
+    private workforceGateReceiptMutation;
+    private workforceTransitionMutation;
+    validateExecutablePackageArtifact(input: ValidateExecutablePackageArtifactInputV1): Promise<ValidateExecutablePackageArtifactResultV1>;
+    describeAiAuthoringContext(input: DescribeAiAuthoringContextRequestV2): Promise<AiAuthoringContextSnapshotV2>;
+    verifyAiAuthoringContextFreshness(input: VerifyAiAuthoringContextFreshnessRequestV2): Promise<AiAuthoringContextVerificationV1>;
+    signAiAuthoringContextLock(input: SignAiAuthoringContextLockRequestV2): Promise<AiAuthoringContextLockV2>;
+    validate(changeSetId: string): Promise<ValidateResult>;
+    validateDeploymentSource(input: {
+        files: RuntimeSourceFile[];
+        targetEnvironment?: string;
+        format?: 'json' | 'markdown';
+    }): Promise<{
+        report: ValidationReport;
+        rendered: string;
+    }>;
+    validateDeploymentPackage(input: {
+        manifest: MetadataPackageManifest;
+        operation: 'install' | 'upgrade';
+        workspaceId?: string;
+        targetEnvironment?: string;
+        format?: 'json' | 'markdown';
+    }): Promise<{
+        report: ValidationReport;
+        rendered: string;
+    }>;
+    createManagedChangeSet(input: Record<string, unknown>): Promise<ManagedChangeSet>;
+    listManagedChangeSets(filters?: Record<string, unknown>): Promise<ManagedChangeSet[]>;
+    getManagedChangeSet(id: string): Promise<ManagedChangeSet>;
+    validateManagedChangeSet(id: string): Promise<{
+        changeSet: ManagedChangeSet;
+        report: ValidationReport;
+    }>;
+    deployManagedChangeSet(id: string): Promise<Record<string, unknown>>;
+    rollbackManagedChangeSet(id: string): Promise<Record<string, unknown>>;
+    getManagedChangeSetDependencies(id: string): Promise<Record<string, unknown>>;
+    getManagedChangeSetConflicts(id: string): Promise<Record<string, unknown>>;
+    approveManagedChangeSet(id: string, reason?: string): Promise<ManagedChangeSet>;
+    rejectManagedChangeSet(id: string, reason?: string): Promise<ManagedChangeSet>;
+    listDeploymentHistory(filters?: Record<string, unknown>): Promise<{
+        records: Record<string, unknown>[];
+        rendered: string;
+    }>;
+    compareDeployments(leftId: string, rightId: string): Promise<Record<string, unknown>>;
+    deploy(changeSetId: string): Promise<DeployResult>;
+    getDeployStatus(jobId: string): Promise<DeployStatus>;
+    retrieve(changeSetId: string): Promise<RetrieveResult>;
+    exportRuntimeMetadata(): Promise<RuntimeExportResult>;
+    validateRuntimeMetadata(files: RuntimeSourceFile[]): Promise<RuntimeValidationResult>;
+    diffRuntimeMetadata(files: RuntimeSourceFile[]): Promise<RuntimePlanResult>;
+    getSourceStatus(): Promise<SourceStatusResult>;
+    getRemoteChanges(workspaceId?: string): Promise<SourceMemberRecord[]>;
+    getLocalChanges(workspaceId?: string): Promise<SourceMemberRecord[]>;
+    getSourceFiles(input?: {
+        paths?: string[];
+        recordAccess?: boolean;
+    }): Promise<SourceFilesResult>;
+    pushSource(input: {
+        files: PushSourceFileInput[];
+        dryRun?: boolean;
+    }): Promise<PushSourceResult>;
+    rebuildSourceBaseline(reason?: string): Promise<SourceBaselineRebuildResult>;
+    importRuntimeMetadata(files: RuntimeSourceFile[], options?: {
+        dryRun?: boolean;
+        destructiveSync?: boolean;
+    }): Promise<RuntimeApplyResult>;
+    getMetadataPackageInstallPlan(input: {
+        workspaceId: string;
+        manifests: MetadataPackageManifest[];
+        dryRun?: boolean;
+        packageDirectory?: string;
+        coreVersion?: string;
+    }): Promise<MetadataPackageInstallPlanResult>;
+    installMetadataPackage(input: {
+        workspaceId: string;
+        manifest: MetadataPackageManifest;
+        dryRun?: boolean;
+        packageDirectory?: string;
+        archivePath?: string;
+        serializerChangeSetId?: string;
+        sourceUri?: string;
+        coreVersion?: string;
+    }): Promise<MetadataPackageInstallResult>;
+    deployEmployeePackage(input: {
+        workspaceId: string;
+        manifest: Record<string, unknown>;
+        dryRun?: boolean;
+        allowMutatingEvals?: boolean;
+        skipEmbeddings?: boolean;
+        forceAdopt?: boolean;
+    }): Promise<EmployeePackageInstallResult>;
+    getEmployeeDeploymentReport(input: {
+        workspaceId: string;
+        deploymentReportId: string;
+    }): Promise<EmployeeDeploymentReportRecord | null>;
+    listEmployeeDeploymentReports(workspaceId: string): Promise<EmployeeDeploymentReportRecord[]>;
+    runRuntimeDemoPreflight(input: {
+        workspaceId: string;
+        expectedCoreSha?: string | null;
+        imageEvidence?: {
+            backendImageSha?: string | null;
+            frontendImageSha?: string | null;
+            mobileImageSha?: string | null;
+            cliImageSha?: string | null;
+        } | null;
+    }): Promise<RuntimeDemoPreflightReport>;
+    getRuntimeDemoPreflightReport(input: {
+        workspaceId: string;
+        preflightReportId: string;
+    }): Promise<RuntimeDemoPreflightReport | null>;
+    registerMetadataInstall(input: {
+        workspaceId: string;
+        packageName: string;
+        version: string;
+        installedStateId: string;
+        compatibleCoreSha: string;
+        auditId?: string | null;
+        sourceUri?: string | null;
+    }): Promise<InstallationContractRecord>;
+    registerBusinessDataInstall(input: {
+        workspaceId: string;
+        contractName: string;
+        contractVersion: string;
+        compatibleCoreSha: string;
+        sourceUri?: string | null;
+        auditId?: string | null;
+        summary?: Record<string, unknown> | null;
+    }): Promise<InstallationContractRecord>;
+    listMetadataInstallations(workspaceId: string): Promise<InstallationContractRecord[]>;
+    listBusinessDataInstallations(workspaceId: string): Promise<InstallationContractRecord[]>;
+    upgradeMetadataPackage(input: {
+        workspaceId: string;
+        manifest: MetadataPackageManifest;
+        allowDestructiveChanges?: boolean;
+        packageDirectory?: string;
+        archivePath?: string;
+        serializerChangeSetId?: string;
+        coreVersion?: string;
+    }): Promise<MetadataPackageUpgradeResult>;
+    uninstallMetadataPackage(input: {
+        workspaceId: string;
+        packageName: string;
+        force?: boolean;
+        purgeMetadata?: boolean;
+    }): Promise<MetadataPackageUninstallResult>;
+    rollbackMetadataPackageInstall(input: {
+        workspaceId: string;
+        manifest: MetadataPackageManifest;
+        deploymentHistoryId?: string;
+        targetStateId?: string;
+        cascade?: boolean;
+        dryRun?: boolean;
+    }): Promise<MetadataPackageRollbackResult>;
+    runtimeComposerPreview(input: {
+        input: RuntimeComposerInput;
+        registryRootDirectories?: string[];
+    }): Promise<RuntimeComposerPreviewResult>;
+    rollbackDeployment(input: {
+        historyId: string;
+        componentIds?: string[];
+    }): Promise<DeploymentRollbackResult>;
+    promoteSandbox(input: PromoteSandboxInput): Promise<boolean>;
+    getSandboxPromotionPrecheck(input: {
+        sandboxId: string;
+    }): Promise<SandboxPromotionPrecheckResult>;
+    codeEnvironmentPromotionPlan(input: {
+        targetWorkspaceId: string;
+        sourceEnvironment?: string | null;
+        runtimePolicyRef?: string | null;
+        allowPartialFailure?: boolean;
+        packages: CodeEnvironmentPromotionPackageInput[];
+    }): Promise<CodeEnvironmentPromotionPlanResult>;
+    promoteCodeEnvironment(input: {
+        targetWorkspaceId: string;
+        sourceEnvironment?: string | null;
+        runtimePolicyRef?: string | null;
+        allowPartialFailure?: boolean;
+        reason?: string | null;
+        packages: CodeEnvironmentPromotionPackageInput[];
+    }): Promise<CodeEnvironmentPromotionResult>;
+    listInstalledMetadataPackages(input: {
+        workspaceId: string;
+        includeUninstalled?: boolean;
+    }): Promise<InstalledMetadataPackageRecord[]>;
+    listMetadataPackageInstallHistory(input: {
+        workspaceId: string;
+        packageName?: string;
+    }): Promise<MetadataPackageInstallHistoryRecord[]>;
+    verifyMetadataPackageSnapshots(input: {
+        workspaceId: string;
+        packageName: string;
+    }): Promise<{
+        workspaceId: string;
+        packageName: string;
+        verification: Array<{
+            snapshotId: string;
+            valid: boolean;
+            status: string;
+        }>;
+    }>;
+    promotePackage(input: {
+        packageName: string;
+        version: string;
+        sourceChannel: string;
+        targetChannel: string;
+        rootDirectory?: string;
+    }): Promise<PromotionRecord>;
+    getPromotionHistory(input: {
+        packageName?: string;
+        version?: string;
+        channel?: string;
+        status?: string;
+    }): Promise<PromotionRecord[]>;
+    getPromotion(id: string): Promise<PromotionRecord>;
+    getRolloutStatus(input: {
+        packageName: string;
+        version: string;
+        channel: string;
+    }): Promise<RolloutStatusResult | null>;
+    updateRolloutPercentage(input: {
+        packageName: string;
+        version: string;
+        channel: string;
+        percentage: number;
+    }): Promise<Record<string, unknown>>;
+    getRolloutWorkspaces(input: {
+        packageName: string;
+        version: string;
+        channel: string;
+        limit?: number;
+    }): Promise<Array<{
+        workspaceId: string;
+        included: boolean;
+    }>>;
+    deprecatePackageVersion(input: {
+        packageName: string;
+        version: string;
+        channel: string;
+        reason: string;
+        replacementVersion?: string;
+        gracePeriodDays?: number;
+    }): Promise<Record<string, unknown>>;
+    getChannelPolicy(): Promise<ChannelPolicyResult>;
+    grantChannelAccess(input: {
+        workspaceId: string;
+        channel: string;
+        reason?: string;
+        expiresAt?: string;
+    }): Promise<ChannelEntitlementRecord>;
+    revokeChannelAccess(input: {
+        entitlementId: string;
+        reason?: string;
+    }): Promise<ChannelEntitlementRecord>;
+    listChannelEntitlements(input: {
+        workspaceId: string;
+        status?: 'active' | 'revoked' | 'all';
+    }): Promise<ChannelEntitlementRecord[]>;
+}
+export declare function createApiClient(targetOrg?: string, requestTimeoutMs?: number): ApiClient;