openxiangda-devkit-core 2.0.0-alpha.12 → 2.0.0-alpha.121

package/dist/application-services.d.ts

@@ -1,6 +1,8 @@
-import { type AppArtifact, type DeploymentRun, type DevkitResult, type Diagnostic, type WorkspaceIdentity } from "openxiangda-contracts";
-import { type CompiledAppPackage } from "openxiangda-compiler";
-import { OpenXiangdaControlPlaneClient, type CreateApplicationSecretInput, type CreateOAuthClientInput, type ControlPlaneClientOptions, type RotateApplicationSecretInput, type UpdateApplicationSecretInput, type UpdateOAuthClientInput } from "./control-plane-client.js";
+import { OPENXIANGDA_CONTRACT_VERSION, SCHEMA_VERSIONS, type DeploymentEnvironment, type DeploymentRun, type DevkitResult, type Diagnostic, type ConfigurationValidationResult, type WorkspaceIdentity } from "openxiangda-contracts";
+import { type CompiledAppPackage } from "./compiler/index.js";
+import { OpenXiangdaControlPlaneClient, type CreateApplicationSecretInput, type CreateNativeRoleMembershipInput, type CreateOAuthClientInput, type ControlPlaneClientOptions, type NativeRelationshipGrantFilter, type RotateApplicationSecretInput, type UpdateApplicationSecretInput, type UpdateNativeRoleMembershipInput, type UpdateOAuthClientInput } from "./control-plane-client.js";
+import { type ToolchainCapsule } from "./toolchain-capsule.js";
+import { type AppSpecContractIndex, type AppSpecRisk } from "./app-spec.js";
 export interface GenerateOptions {
     root?: string;
     check?: boolean;
@@ -13,13 +15,32 @@ export interface BuildOptions {
 }
 export interface BuiltApplication {
     package: CompiledAppPackage;
+    sealedArtifact: SealedArtifactStatus;
     outputDirectory?: string;
 }
-interface SealedApplication extends BuiltApplication {
-    artifactContent: Record<string, string>;
+export interface SealedArtifactStatus {
+    schemaVersion: "openxiangda.sealed-artifact-status/v2";
+    state: "check-did-not-seal" | "sealed";
+    sealed: boolean;
+    usableForDeploy: boolean;
+    refreshedBy: "check" | "build";
+    persisted: boolean;
+    statusPath: ".openxiangda/build/seal-status.json";
+    manifestPath: ".openxiangda/build/app-package.json";
+    workspaceRevision: string | null;
+    workspaceDirty: boolean;
+    packageDigest: string | null;
+    previousArtifact?: {
+        packageDigest: string | null;
+        sourceRevision: string | null;
+        sourceDirty: boolean | null;
+        matchesWorkspaceSource: boolean;
+    };
+    reasonCode?: "OPENXIANGDA_CHECK_DOES_NOT_SEAL";
+    nextCommand: "openxiangda check" | "openxiangda deploy";
 }
 export interface DeployOptions extends BuildOptions {
-    environment: "development" | "preproduction" | "production";
+    environment: "preproduction";
     environmentId?: string;
     idempotencyKey?: string;
     requestId?: string;
@@ -28,17 +49,434 @@ export declare class OpenXiangdaApplicationServices {
     private readonly options;
     constructor(options?: {
         toolchainVersion?: string;
+        toolchainCapsule?: ToolchainCapsule;
         client?: OpenXiangdaControlPlaneClient;
         clientOptions?: ControlPlaneClientOptions;
     });
-    workspaceContext(root?: string): Promise<DevkitResult<import("openxiangda-contracts").WorkspaceContext>>;
+    workspaceContext(root?: string): Promise<DevkitResult<{
+        development: {
+            application: {
+                path: string;
+                content: string;
+            } | null;
+            records: {
+                id: string;
+                title: string;
+                status: string;
+                path: string;
+                kind: import("./app-spec.js").AppSpecDocumentKind;
+            }[];
+            schemaVersion: "openxiangda.development-lifecycle/v2";
+            stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+            readyForImplementation: boolean;
+            design: {
+                readyForImplementation: boolean;
+                reviewId: string | null;
+                scope: "change" | "initial" | null;
+                baselineDigest: string | null;
+                documentIds: string[];
+                diagnostics: Diagnostic[];
+            };
+            readyForTest: boolean;
+            changeId: string | null;
+            acceptanceIds: string[];
+            currentSpecDigest: string | null;
+            diagnostics: Diagnostic[];
+            nextCommand: string;
+        };
+        schemaVersion: typeof SCHEMA_VERSIONS.workspaceContext;
+        workspace: WorkspaceIdentity;
+        roots: {
+            frontend: string;
+            backend: string;
+            platform: string;
+        };
+        toolchain: {
+            packageName?: "openxiangda-devkit-core";
+            version: string;
+            contractVersion: typeof OPENXIANGDA_CONTRACT_VERSION;
+            nodeVersion: string;
+            packageManager: string;
+            studio?: import("openxiangda-contracts").StudioWorkspaceProtocolCapabilities;
+        };
+        environments: Array<{
+            id?: string;
+            name: string;
+            kind: DeploymentEnvironment;
+        }>;
+        changedDomains: Array<"frontend" | "backend" | "data" | "authz" | "events" | "workflow" | "config">;
+    }>>;
+    appSpecInit(root?: string): Promise<DevkitResult<{
+        schemaVersion: "openxiangda.appspec/context/v4";
+        enabled: boolean;
+        advisory: boolean;
+        releaseGate: boolean;
+        created: string[];
+        existing: string[];
+    }>>;
+    appSpecAddCapability(input: {
+        root?: string;
+        id: string;
+        title: string;
+        resources?: string[];
+        actions?: string[];
+    }): Promise<DevkitResult<{
+        schemaVersion: "openxiangda.appspec/context/v4";
+        enabled: boolean;
+        advisory: boolean;
+        releaseGate: boolean;
+        created: string;
+    }>>;
+    appSpecNew(input: {
+        root?: string;
+        id: string;
+        title: string;
+        risk?: AppSpecRisk;
+        summary?: string;
+        capabilities?: string[];
+        requirements?: string[];
+        resources?: string[];
+        actions?: string[];
+    }): Promise<DevkitResult<{
+        schemaVersion: "openxiangda.appspec/context/v4";
+        enabled: boolean;
+        advisory: boolean;
+        releaseGate: boolean;
+        created: string;
+        risk: AppSpecRisk;
+        status: string;
+    }>>;
+    appSpecContext(root?: string, selector?: string, historyOffset?: number): Promise<DevkitResult<{
+        lifecycle: {
+            schemaVersion: "openxiangda.development-lifecycle/v2";
+            stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+            readyForImplementation: boolean;
+            design: {
+                readyForImplementation: boolean;
+                reviewId: string | null;
+                scope: "change" | "initial" | null;
+                baselineDigest: string | null;
+                documentIds: string[];
+                diagnostics: Diagnostic[];
+            };
+            readyForTest: boolean;
+            changeId: string | null;
+            acceptanceIds: string[];
+            currentSpecDigest: string | null;
+            diagnostics: Diagnostic[];
+            nextCommand: string;
+        };
+        schemaVersion: "openxiangda.appspec/context/v4";
+        enabled: boolean;
+        mode: "guided";
+        releaseGate: true;
+        root: "appspec";
+        selector: string | null;
+        contract: AppSpecContractIndex;
+        index: {
+            application: import("./app-spec.js").AppSpecDocumentSummary | null;
+            capabilities: import("./app-spec.js").AppSpecDocumentSummary[];
+            activeChanges: import("./app-spec.js").AppSpecDocumentSummary[];
+            decisions: import("./app-spec.js").AppSpecDocumentSummary[];
+            designs: import("./app-spec.js").AppSpecDocumentSummary[];
+            history: import("./app-spec.js").AppSpecDocumentSummary[];
+        };
+        application: import("./app-spec.js").AppSpecDocument | null;
+        capabilities: import("./app-spec.js").AppSpecDocument[];
+        activeChanges: import("./app-spec.js").AppSpecDocument[];
+        archivedChanges: import("./app-spec.js").AppSpecDocument[];
+        decisions: import("./app-spec.js").AppSpecDocument[];
+        designs: import("./app-spec.js").AppSpecDocument[];
+        historyPage: {
+            offset: number;
+            limit: number;
+            total: number;
+            nextOffset: number | null;
+        };
+        contextBudget: {
+            maximumBytes: number;
+            contentBytes: number;
+            truncated: boolean;
+            omitted: import("./app-spec.js").AppSpecDocumentSummary[];
+        };
+        stats: {
+            files: number;
+            bytes: number;
+            capabilities: number;
+            activeChanges: number;
+            historyChanges: number;
+            decisions: number;
+            designs: number;
+            requirements: number;
+            acceptanceScenarios: number;
+        };
+        workspaceDigest: string | null;
+        selectionDigest: string | null;
+        diagnostics: Diagnostic[];
+    }>>;
+    appSpecCheck(root?: string): Promise<DevkitResult<{
+        lifecycle: {
+            schemaVersion: "openxiangda.development-lifecycle/v2";
+            stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+            readyForImplementation: boolean;
+            design: {
+                readyForImplementation: boolean;
+                reviewId: string | null;
+                scope: "change" | "initial" | null;
+                baselineDigest: string | null;
+                documentIds: string[];
+                diagnostics: Diagnostic[];
+            };
+            readyForTest: boolean;
+            changeId: string | null;
+            acceptanceIds: string[];
+            currentSpecDigest: string | null;
+            diagnostics: Diagnostic[];
+            nextCommand: string;
+        };
+        schemaVersion: "openxiangda.appspec/context/v4";
+        enabled: boolean;
+        mode: "guided";
+        releaseGate: true;
+        root: "appspec";
+        selector: string | null;
+        contract: AppSpecContractIndex;
+        index: {
+            application: import("./app-spec.js").AppSpecDocumentSummary | null;
+            capabilities: import("./app-spec.js").AppSpecDocumentSummary[];
+            activeChanges: import("./app-spec.js").AppSpecDocumentSummary[];
+            decisions: import("./app-spec.js").AppSpecDocumentSummary[];
+            designs: import("./app-spec.js").AppSpecDocumentSummary[];
+            history: import("./app-spec.js").AppSpecDocumentSummary[];
+        };
+        application: import("./app-spec.js").AppSpecDocument | null;
+        capabilities: import("./app-spec.js").AppSpecDocument[];
+        activeChanges: import("./app-spec.js").AppSpecDocument[];
+        archivedChanges: import("./app-spec.js").AppSpecDocument[];
+        decisions: import("./app-spec.js").AppSpecDocument[];
+        designs: import("./app-spec.js").AppSpecDocument[];
+        historyPage: {
+            offset: number;
+            limit: number;
+            total: number;
+            nextOffset: number | null;
+        };
+        contextBudget: {
+            maximumBytes: number;
+            contentBytes: number;
+            truncated: boolean;
+            omitted: import("./app-spec.js").AppSpecDocumentSummary[];
+        };
+        stats: {
+            files: number;
+            bytes: number;
+            capabilities: number;
+            activeChanges: number;
+            historyChanges: number;
+            decisions: number;
+            designs: number;
+            requirements: number;
+            acceptanceScenarios: number;
+        };
+        workspaceDigest: string | null;
+        selectionDigest: string | null;
+        diagnostics: Diagnostic[];
+    }>>;
+    appSpecVerify(root: string | undefined, deploymentId: string, evidencePath?: string): Promise<DevkitResult<{
+        ok: boolean;
+        path: string;
+        sourceDeploymentId: string;
+        packageDigest: string;
+        scenarios: any;
+        diagnostics: Diagnostic[];
+    }>>;
+    appSpecClose(input: {
+        root?: string;
+        id: string;
+        summary?: string;
+        currentSpec?: "merged" | "not-applicable";
+    }): Promise<DevkitResult<{
+        schemaVersion: "openxiangda.appspec/context/v4";
+        enabled: boolean;
+        advisory: boolean;
+        releaseGate: boolean;
+        archived: null;
+        status: string;
+        converged: boolean;
+    } | {
+        schemaVersion: "openxiangda.appspec/context/v4";
+        enabled: boolean;
+        advisory: boolean;
+        releaseGate: boolean;
+        archived: string;
+        status: string;
+        converged: boolean;
+    }>>;
+    accept(input: {
+        root?: string;
+        planPath: string;
+    }): Promise<DevkitResult<undefined> | DevkitResult<{
+        schemaVersion: "openxiangda.preproduction-acceptance-identities/v2";
+        appCode: string;
+        environmentKey: "preproduction";
+        expiresAt: string;
+        actors: Array<{
+            key: string;
+            userId: string;
+            roleCodes: string[];
+            expiresAt: string;
+            loginUrl: string;
+            loginUrlExpiresAt: string;
+        }>;
+        manual: boolean;
+        releaseGate: boolean;
+        planPath: string;
+    }>>;
     contractDescribe(root?: string): Promise<DevkitResult<{
         configDigest: string;
         contractDigest: string;
-        contract: import("openxiangda-compiler").ContractBundleV2;
+        aiCatalogDigest: string;
+        contract: import("openxiangda-contracts").ContractBundleV3;
+        aiCatalog: import("openxiangda-contracts").AiCapabilityCatalog;
+        permissionReview: {
+            digest: string;
+            schemaVersion: "openxiangda.permission-review/v2";
+            appCode: string;
+            configDigest: string;
+            contractDigest: string;
+            authority: "declaration-projection";
+            runtimeAuthorizationRequired: true;
+            semantics: {
+                roleCapabilities: "sealed-declared-grants; current-user application roles are unioned";
+                roleDeniedCapabilities: "removed from that role during compilation; not a global deny across roles";
+                capabilityMatch: "static prerequisite only; never runtime allow";
+                fieldPolicies: "resource operation is required; field rules can only narrow it; empty is deny";
+                hiddenFields: "presentation only; not an authorization rule";
+                rowPolicies: "raw declarations; evaluated by the platform with current identity, grants and record facts";
+                workflowTasks: "platform Task Surface and fresh command token decide current participant, state, field and operation access";
+                navigation: "page selection and visibility do not grant resource or operation access";
+                perspectives: "read projections only; never replace the actor or mutation/workflow authorization";
+            };
+            roles: {
+                capabilityCodes: string[];
+                description?: string;
+                code: string;
+                name: string;
+            }[];
+            capabilities: import("openxiangda-contracts").AppCapabilityContract[];
+            perspectives: import("openxiangda-contracts").AppPerspectiveContract[];
+            pages: {
+                adminAccess: import("openxiangda-contracts").AppFrontendRouteAccess | null;
+                admin: import("openxiangda-contracts").AppAdminPageContract[];
+                custom: import("openxiangda-contracts").AppFrontendRouteContract[];
+                standard: import("openxiangda-contracts").AppRouteManifestEntryV3[];
+            };
+            resources: {
+                code: string;
+                name: string;
+                operationCapabilities: {
+                    read: string;
+                    create: string;
+                    update: string;
+                    delete: string;
+                };
+                dataPolicyCode: string | null;
+                mutationOwner: "native" | "action" | "readonly" | "workflow" | null;
+                generated: {
+                    list?: boolean;
+                    detail?: boolean;
+                    create?: boolean;
+                    update?: boolean;
+                    delete?: boolean;
+                } | null;
+                views: {
+                    code: string;
+                    name: string;
+                    generated: Required<{
+                        list?: boolean;
+                        detail?: boolean;
+                        create?: boolean;
+                        update?: boolean;
+                        delete?: boolean;
+                    }>;
+                    fieldOrder: {
+                        list: string[];
+                        form: string[];
+                        detail: string[];
+                    };
+                    mobile: {
+                        enabled: boolean;
+                    };
+                }[];
+                defaultFieldOrder: {
+                    list: string[] | null;
+                    form: string[] | null;
+                    detail: string[] | null;
+                } | null;
+                fields: {
+                    code: string;
+                    type: "boolean" | "date" | "file" | "subtable" | "text.short" | "text.long" | "text.rich" | "number.integer" | "number.decimal" | "time" | "datetime" | "date-range" | "datetime-range" | "option.single" | "option.multiple" | "cascade.single" | "cascade.multiple" | "user.single" | "user.multiple" | "department.single" | "department.multiple" | "resource-ref.single" | "resource-ref.multiple" | "image" | "signature" | "address" | "location" | "uuid" | "json" | "serial-number";
+                    label: string;
+                    hidden: boolean;
+                    system: boolean;
+                    read: import("./compiler/permission-review.js").PermissionReviewFieldRequirement;
+                    create: import("./compiler/permission-review.js").PermissionReviewFieldRequirement;
+                    update: import("./compiler/permission-review.js").PermissionReviewFieldRequirement;
+                    mask: "null" | "omit" | null;
+                }[];
+            }[];
+            authorization: {
+                authenticatedUserRoleCode: string | null;
+                dataPolicies: import("openxiangda-contracts").AppDataPolicyDeclaration[];
+                scopeDimensions: import("openxiangda-contracts").AppScopeDimensionDeclaration[];
+                scopeSources: import("openxiangda-contracts").AppScopeSourceDeclaration[];
+                roleMembershipSources: import("openxiangda-contracts").AppRoleMembershipSourceDeclaration[];
+                relationshipGrantSources: import("openxiangda-contracts").AppRelationshipGrantSourceDeclaration[];
+                authorizationTransitions: import("openxiangda-contracts").AppAuthorizationTransitionDeclaration[];
+                publicAccess: import("openxiangda-contracts").AnonymousPublicAccessContractV2 | null;
+            };
+            operations: import("openxiangda-contracts").AppApiOperationContract[];
+            workflows: {
+                runtimeAuthorizationRequired: true;
+                contracts: import("openxiangda-contracts").AppWorkflowContract[];
+                definitions: {
+                    workflowCode: string;
+                    version: number;
+                    subject: import("openxiangda-contracts").WorkflowSubjectDefinition;
+                    organizationContext: {
+                        department?: {
+                            source: "none" | "user_primary_department" | "choose_if_multiple" | "always_choose" | "fixed" | "from_input" | "from_role_scope";
+                            required?: boolean;
+                            value?: string;
+                            path?: string;
+                            dimension?: string;
+                        };
+                    } | null;
+                    startAt: string;
+                    nodes: Record<string, import("openxiangda-contracts").WorkflowNode>;
+                }[];
+                bindings: import("openxiangda-contracts").NativeWorkflowBindingDeclaration[];
+                activations: import("openxiangda-contracts").NativeWorkflowActivationDeclaration[];
+                providers: import("openxiangda-contracts").NativeWorkflowProviderDeclaration[];
+                editableParameters: import("openxiangda-contracts").NativeWorkflowEditableParameterDeclaration[];
+            };
+        };
+        adminNavigationAuthoring: {
+            schemaVersion: string;
+            owner: string;
+            target: string;
+            configured: boolean;
+            applyMode: string;
+            automaticRuntimeDiscovery: boolean;
+            suggestion: import("./compiler/config.js").AdminNavigationSuggestionSource;
+        };
         counts: {
             backendSecrets: number;
+            backendOperations: number;
+            frontendRoutes: number;
+            anonymousPublicPolicies: number;
             dataResources: number;
+            aiCapabilities: number;
             eventSubscriptions: number;
             timerSubscriptions: number;
             workflowDefinitions: number;
@@ -46,8 +484,42 @@ export declare class OpenXiangdaApplicationServices {
             workflowProviders: number;
         };
     }>>;
+    contractContext(root?: string, input?: {
+        selector?: string;
+        offset?: number;
+        limit?: number;
+    }): Promise<{
+        data: {
+            configDigest: string;
+            contractDigest: string;
+            aiCatalogDigest: string;
+            counts: {
+                backendSecrets: number;
+                backendOperations: number;
+                frontendRoutes: number;
+                anonymousPublicPolicies: number;
+                dataResources: number;
+                aiCapabilities: number;
+                eventSubscriptions: number;
+                timerSubscriptions: number;
+                workflowDefinitions: number;
+                workflowBindings: number;
+                workflowProviders: number;
+            };
+            selector: string;
+            selection: unknown;
+        };
+        ok: boolean;
+        operation: string;
+        workspace: WorkspaceIdentity;
+        diagnostics: Diagnostic[];
+        nextActions: import("openxiangda-contracts").NextAction[];
+        traceId?: string;
+    }>;
     platformCapabilities(root?: string): Promise<DevkitResult<import("openxiangda-contracts").PlatformCapabilities>>;
-    provisionApplication(root?: string): Promise<DevkitResult<import("openxiangda-contracts").ProvisionedApplication>>;
+    administrationContext(root: string | undefined, environmentKey?: string): Promise<DevkitResult<import("openxiangda-contracts").ApplicationAdministrationContext>>;
+    workflowNodeConfigurations(root: string | undefined, workflowCode: string, environmentKey?: string): Promise<DevkitResult<import("openxiangda-contracts").WorkflowNodeConfigurations>>;
+    provisionApplication(root?: string): Promise<DevkitResult<undefined> | DevkitResult<import("openxiangda-contracts").ProvisionedApplication>>;
     oauthClients(root?: string): Promise<DevkitResult<{
         items: import("openxiangda-contracts").OAuthClient[];
         total: number;
@@ -72,7 +544,7 @@ export declare class OpenXiangdaApplicationServices {
     rotateOAuthClientSecret(root: string | undefined, clientId: string, gracePeriodSeconds?: number): Promise<DevkitResult<import("./control-plane-client.js").OAuthClientSecretResult>>;
     revokeOAuthClient(root: string | undefined, clientId: string): Promise<DevkitResult<import("openxiangda-contracts").OAuthClient>>;
     oauthAuditEvents(root: string | undefined, input?: {
-        environmentKey?: string;
+        environmentKey?: DeploymentEnvironment | string;
         clientId?: string;
         limit?: number;
     }): Promise<DevkitResult<{
@@ -93,6 +565,64 @@ export declare class OpenXiangdaApplicationServices {
     applicationSecretAuditEvents(root: string | undefined, environmentKey: string, name: string, limit?: number): Promise<DevkitResult<{
         items: import("openxiangda-contracts").ApplicationSecretAuditEvent[];
     }>>;
+    nativeRoleMemberships(root: string | undefined, environmentKey: string, input?: {
+        status?: "active" | "revoked" | "expired";
+        userId?: string;
+        roleCode?: string;
+        keyword?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<DevkitResult<import("openxiangda-contracts").NativeRoleMembershipPage>>;
+    createNativeRoleMembership(root: string | undefined, input: CreateNativeRoleMembershipInput): Promise<DevkitResult<import("openxiangda-contracts").NativeRoleMembershipMutationResult>>;
+    updateNativeRoleMembership(root: string | undefined, membershipId: string, input: UpdateNativeRoleMembershipInput): Promise<DevkitResult<import("openxiangda-contracts").NativeRoleMembershipMutationResult>>;
+    revokeNativeRoleMembership(root: string | undefined, membershipId: string, input: {
+        environmentKey: DeploymentEnvironment;
+        operationId: string;
+        expectedRevision: number;
+        reason: string;
+    }): Promise<DevkitResult<import("openxiangda-contracts").NativeRoleMembershipMutationResult>>;
+    nativeSuperAdmins(root: string | undefined, environmentKey: string, input?: {
+        status?: "active" | "revoked";
+        userId?: string;
+        keyword?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<DevkitResult<import("openxiangda-contracts").NativeSuperAdminGrantPage>>;
+    grantNativeSuperAdmin(root: string | undefined, environmentKey: string, input: {
+        operationId: string;
+        userId: string;
+    }): Promise<DevkitResult<{
+        grant: import("openxiangda-contracts").NativeSuperAdminGrant;
+        environmentSubjectVersions: Array<Record<string, unknown>>;
+        revokedSessionCount: number;
+    }>>;
+    revokeNativeSuperAdmin(root: string | undefined, environmentKey: string, grantId: string, input: {
+        operationId: string;
+        expectedRevision: number;
+    }): Promise<DevkitResult<{
+        grant: import("openxiangda-contracts").NativeSuperAdminGrant;
+        environmentSubjectVersions: Array<Record<string, unknown>>;
+        revokedSessionCount: number;
+    }>>;
+    nativeRelationshipGrants(root: string | undefined, environmentKey: string, input?: Omit<NativeRelationshipGrantFilter, "environmentKey">): Promise<DevkitResult<import("openxiangda-contracts").NativeRelationshipGrantPage>>;
+    createNativeRelationshipGrant(root: string | undefined, input: Parameters<OpenXiangdaControlPlaneClient["createNativeRelationshipGrant"]>[1]): Promise<DevkitResult<{
+        grant: import("openxiangda-contracts").NativeRelationshipGrant;
+    }>>;
+    updateNativeRelationshipGrant(root: string | undefined, grantId: string, input: Parameters<OpenXiangdaControlPlaneClient["updateNativeRelationshipGrant"]>[2]): Promise<DevkitResult<{
+        grant: import("openxiangda-contracts").NativeRelationshipGrant;
+    }>>;
+    revokeNativeRelationshipGrant(root: string | undefined, grantId: string, input: Parameters<OpenXiangdaControlPlaneClient["revokeNativeRelationshipGrant"]>[2]): Promise<DevkitResult<{
+        grant: import("openxiangda-contracts").NativeRelationshipGrant;
+    }>>;
+    nativeAuthorizationProjectionHealth(root: string | undefined, environmentKey: string): Promise<DevkitResult<import("openxiangda-contracts").NativeAuthorizationProjectionHealth>>;
+    rebuildNativeAuthorizationProjections(root: string | undefined, input: {
+        environmentKey: DeploymentEnvironment;
+        operationId: string;
+    }): Promise<DevkitResult<import("openxiangda-contracts").NativeAuthorizationProjectionMutationResult>>;
+    recoverNativeAuthorizationProjection(root: string | undefined, jobId: string, input: {
+        environmentKey: DeploymentEnvironment;
+        operationId: string;
+    }): Promise<DevkitResult<import("openxiangda-contracts").NativeAuthorizationProjectionMutationResult>>;
     eventSubscriptions(root?: string): Promise<DevkitResult<{
         items: import("openxiangda-contracts").EventSubscription[];
     }>>;
@@ -100,11 +630,6 @@ export declare class OpenXiangdaApplicationServices {
         expectedRevision: number;
         status: "active" | "paused";
     }): Promise<DevkitResult<import("openxiangda-contracts").EventSubscription>>;
-    rotateEventSubscriptionSecret(root: string | undefined, subscriptionId: string, input: {
-        expectedRevision: number;
-        idempotencyKey: string;
-        gracePeriodSeconds?: number;
-    }): Promise<DevkitResult<import("openxiangda-contracts").EventSubscription>>;
     eventDeliveries(root: string | undefined, limit?: number): Promise<DevkitResult<{
         items: import("openxiangda-contracts").EventDelivery[];
     }>>;
@@ -129,49 +654,267 @@ export declare class OpenXiangdaApplicationServices {
         environments?: Array<{
             id?: string;
             name: string;
-            kind: "development" | "preproduction" | "production";
+            kind: DeploymentEnvironment;
         }>;
     }): Promise<DevkitResult<{
         schemaVersion: number;
         appCode: string;
         baseUrl: string;
         environments: {
+            kind: "preproduction" | "production";
             id?: string;
             name: string;
-            kind: "development" | "preproduction" | "production";
         }[];
         path: string;
     }>>;
-    generate(input?: GenerateOptions): Promise<DevkitResult<{
+    generate(input?: GenerateOptions): Promise<DevkitResult<undefined> | DevkitResult<{
         output: string;
         changed: boolean;
         contractDigest: string;
+        aiCatalogDigest: string;
     }>>;
-    check(root?: string): Promise<DevkitResult<{
+    check(root?: string, environmentKey?: DeploymentEnvironment): Promise<DevkitResult<undefined> | DevkitResult<{
+        generated: {
+            output: string;
+            changed: boolean;
+            contractDigest: string;
+            aiCatalogDigest: string;
+        } | undefined;
+        compatibility: ConfigurationValidationResult | null;
         stages: {
+            name: string;
+            state: "passed" | "failed" | "skipped";
             ok: boolean;
-            exitCode: number;
+            exitCode: number | null;
             output: string;
-            name: string;
+            reused?: boolean;
         }[];
+        sealedArtifact: SealedArtifactStatus;
+        appSpec: {
+            lifecycle: {
+                schemaVersion: "openxiangda.development-lifecycle/v2";
+                stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+                readyForImplementation: boolean;
+                design: {
+                    readyForImplementation: boolean;
+                    reviewId: string | null;
+                    scope: "change" | "initial" | null;
+                    baselineDigest: string | null;
+                    documentIds: string[];
+                    diagnostics: Diagnostic[];
+                };
+                readyForTest: boolean;
+                changeId: string | null;
+                acceptanceIds: string[];
+                currentSpecDigest: string | null;
+                diagnostics: Diagnostic[];
+                nextCommand: string;
+            };
+            enabled: boolean;
+            mode: "guided";
+            releaseGate: true;
+            workspaceDigest: string | null;
+            selectionDigest: string | null;
+            historyPage: {
+                offset: number;
+                limit: number;
+                total: number;
+                nextOffset: number | null;
+            };
+            contextBudget: {
+                maximumBytes: number;
+                contentBytes: number;
+                truncated: boolean;
+                omitted: import("./app-spec.js").AppSpecDocumentSummary[];
+            };
+            stats: {
+                files: number;
+                bytes: number;
+                capabilities: number;
+                activeChanges: number;
+                historyChanges: number;
+                decisions: number;
+                designs: number;
+                requirements: number;
+                acceptanceScenarios: number;
+            };
+            diagnostics: {
+                errors: number;
+                warnings: number;
+                info: number;
+            };
+            nextCommand: string;
+        };
     }>>;
-    test(root?: string): Promise<DevkitResult<{
+    test(root?: string): Promise<DevkitResult<undefined> | DevkitResult<{
         ok: boolean;
         exitCode: number;
         output: string;
+        outputTruncated: boolean;
     }>>;
     build(input?: BuildOptions): Promise<DevkitResult<BuiltApplication>>;
-    private buildSealed;
-    deploymentPlan(input: BuildOptions & {
-        environment: string;
-    }): Promise<DevkitResult<BuiltApplication> | {
+    buildPreview(root?: string): Promise<{
         operation: string;
         data: {
-            environment: string;
-            packageDigest: string;
-            appCode: string;
-            artifacts: AppArtifact[];
-            requiredCapabilities: string[];
+            sealed: boolean;
+            packageDigest: null;
+            check: {
+                generated: {
+                    output: string;
+                    changed: boolean;
+                    contractDigest: string;
+                    aiCatalogDigest: string;
+                } | undefined;
+                compatibility: ConfigurationValidationResult | null;
+                stages: {
+                    name: string;
+                    state: "passed" | "failed" | "skipped";
+                    ok: boolean;
+                    exitCode: number | null;
+                    output: string;
+                    reused?: boolean;
+                }[];
+                sealedArtifact: SealedArtifactStatus;
+                appSpec: {
+                    lifecycle: {
+                        schemaVersion: "openxiangda.development-lifecycle/v2";
+                        stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+                        readyForImplementation: boolean;
+                        design: {
+                            readyForImplementation: boolean;
+                            reviewId: string | null;
+                            scope: "change" | "initial" | null;
+                            baselineDigest: string | null;
+                            documentIds: string[];
+                            diagnostics: Diagnostic[];
+                        };
+                        readyForTest: boolean;
+                        changeId: string | null;
+                        acceptanceIds: string[];
+                        currentSpecDigest: string | null;
+                        diagnostics: Diagnostic[];
+                        nextCommand: string;
+                    };
+                    enabled: boolean;
+                    mode: "guided";
+                    releaseGate: true;
+                    workspaceDigest: string | null;
+                    selectionDigest: string | null;
+                    historyPage: {
+                        offset: number;
+                        limit: number;
+                        total: number;
+                        nextOffset: number | null;
+                    };
+                    contextBudget: {
+                        maximumBytes: number;
+                        contentBytes: number;
+                        truncated: boolean;
+                        omitted: import("./app-spec.js").AppSpecDocumentSummary[];
+                    };
+                    stats: {
+                        files: number;
+                        bytes: number;
+                        capabilities: number;
+                        activeChanges: number;
+                        historyChanges: number;
+                        decisions: number;
+                        designs: number;
+                        requirements: number;
+                        acceptanceScenarios: number;
+                    };
+                    diagnostics: {
+                        errors: number;
+                        warnings: number;
+                        info: number;
+                    };
+                    nextCommand: string;
+                };
+            } | undefined;
+        };
+        ok: boolean;
+        workspace: WorkspaceIdentity;
+        diagnostics: Diagnostic[];
+        nextActions: import("openxiangda-contracts").NextAction[];
+        traceId?: string;
+    } | {
+        operation: string;
+        data: {
+            sealed: boolean;
+            packageDigest: null;
+            check: {
+                generated: {
+                    output: string;
+                    changed: boolean;
+                    contractDigest: string;
+                    aiCatalogDigest: string;
+                } | undefined;
+                compatibility: ConfigurationValidationResult | null;
+                stages: {
+                    name: string;
+                    state: "passed" | "failed" | "skipped";
+                    ok: boolean;
+                    exitCode: number | null;
+                    output: string;
+                    reused?: boolean;
+                }[];
+                sealedArtifact: SealedArtifactStatus;
+                appSpec: {
+                    lifecycle: {
+                        schemaVersion: "openxiangda.development-lifecycle/v2";
+                        stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+                        readyForImplementation: boolean;
+                        design: {
+                            readyForImplementation: boolean;
+                            reviewId: string | null;
+                            scope: "change" | "initial" | null;
+                            baselineDigest: string | null;
+                            documentIds: string[];
+                            diagnostics: Diagnostic[];
+                        };
+                        readyForTest: boolean;
+                        changeId: string | null;
+                        acceptanceIds: string[];
+                        currentSpecDigest: string | null;
+                        diagnostics: Diagnostic[];
+                        nextCommand: string;
+                    };
+                    enabled: boolean;
+                    mode: "guided";
+                    releaseGate: true;
+                    workspaceDigest: string | null;
+                    selectionDigest: string | null;
+                    historyPage: {
+                        offset: number;
+                        limit: number;
+                        total: number;
+                        nextOffset: number | null;
+                    };
+                    contextBudget: {
+                        maximumBytes: number;
+                        contentBytes: number;
+                        truncated: boolean;
+                        omitted: import("./app-spec.js").AppSpecDocumentSummary[];
+                    };
+                    stats: {
+                        files: number;
+                        bytes: number;
+                        capabilities: number;
+                        activeChanges: number;
+                        historyChanges: number;
+                        decisions: number;
+                        designs: number;
+                        requirements: number;
+                        acceptanceScenarios: number;
+                    };
+                    diagnostics: {
+                        errors: number;
+                        warnings: number;
+                        info: number;
+                    };
+                    nextCommand: string;
+                };
+            } | undefined;
         };
         ok: boolean;
         workspace: WorkspaceIdentity;
@@ -179,12 +922,187 @@ export declare class OpenXiangdaApplicationServices {
         nextActions: import("openxiangda-contracts").NextAction[];
         traceId?: string;
     }>;
-    deploy(input: DeployOptions): Promise<DevkitResult<SealedApplication> | DevkitResult<undefined> | DevkitResult<DeploymentRun>>;
-    deploymentStatus(root: string | undefined, deploymentId?: string): Promise<DevkitResult<DeploymentRun | {
-        items: DeploymentRun[];
-        total: number;
+    private buildSealed;
+    deploymentPlan(input: {
+        root?: string;
+        environment: "preproduction";
+    }): Promise<DevkitResult<undefined> | DevkitResult<{
+        lifecycle: {
+            schemaVersion: "openxiangda.development-lifecycle/v2";
+            stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+            readyForImplementation: boolean;
+            design: {
+                readyForImplementation: boolean;
+                reviewId: string | null;
+                scope: "change" | "initial" | null;
+                baselineDigest: string | null;
+                documentIds: string[];
+                diagnostics: Diagnostic[];
+            };
+            readyForTest: boolean;
+            changeId: string | null;
+            acceptanceIds: string[];
+            currentSpecDigest: string | null;
+            diagnostics: Diagnostic[];
+            nextCommand: string;
+        };
+    }> | DevkitResult<{
+        environment: "preproduction";
+        appCode: string;
+        sealed: boolean;
+        packageDigest: null;
+        buildOwner: string;
+        source: import("./delivery-source.js").PublishedDeliverySource;
+        frontendRoot: string;
+        backendRoot: string;
+        configDigest: string;
+        contractDigest: string;
     }>>;
-    deploymentLogs(root: string | undefined, deploymentId: string): Promise<{
+    deploy(input: DeployOptions): Promise<DevkitResult<undefined> | DevkitResult<{
+        lifecycle: {
+            schemaVersion: "openxiangda.development-lifecycle/v2";
+            stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+            readyForImplementation: boolean;
+            design: {
+                readyForImplementation: boolean;
+                reviewId: string | null;
+                scope: "change" | "initial" | null;
+                baselineDigest: string | null;
+                documentIds: string[];
+                diagnostics: Diagnostic[];
+            };
+            readyForTest: boolean;
+            changeId: string | null;
+            acceptanceIds: string[];
+            currentSpecDigest: string | null;
+            diagnostics: Diagnostic[];
+            nextCommand: string;
+        };
+    }> | DevkitResult<{
+        sealedArtifact: SealedArtifactStatus;
+        package: CompiledAppPackage;
+        artifactContent: Record<string, string>;
+    }> | DevkitResult<DeploymentRun> | {
+        operation: string;
+        ok: boolean;
+        workspace: WorkspaceIdentity;
+        data?: {
+            output: string;
+            changed: boolean;
+            contractDigest: string;
+            aiCatalogDigest: string;
+        };
+        diagnostics: Diagnostic[];
+        nextActions: import("openxiangda-contracts").NextAction[];
+        traceId?: string;
+    } | {
+        operation: string;
+        ok: boolean;
+        workspace: WorkspaceIdentity;
+        data?: {
+            generated: {
+                output: string;
+                changed: boolean;
+                contractDigest: string;
+                aiCatalogDigest: string;
+            } | undefined;
+            compatibility: ConfigurationValidationResult | null;
+            stages: {
+                name: string;
+                state: "passed" | "failed" | "skipped";
+                ok: boolean;
+                exitCode: number | null;
+                output: string;
+                reused?: boolean;
+            }[];
+            sealedArtifact: SealedArtifactStatus;
+            appSpec: {
+                lifecycle: {
+                    schemaVersion: "openxiangda.development-lifecycle/v2";
+                    stage: "design-incomplete" | "ready-for-implementation" | "ready-for-test";
+                    readyForImplementation: boolean;
+                    design: {
+                        readyForImplementation: boolean;
+                        reviewId: string | null;
+                        scope: "change" | "initial" | null;
+                        baselineDigest: string | null;
+                        documentIds: string[];
+                        diagnostics: Diagnostic[];
+                    };
+                    readyForTest: boolean;
+                    changeId: string | null;
+                    acceptanceIds: string[];
+                    currentSpecDigest: string | null;
+                    diagnostics: Diagnostic[];
+                    nextCommand: string;
+                };
+                enabled: boolean;
+                mode: "guided";
+                releaseGate: true;
+                workspaceDigest: string | null;
+                selectionDigest: string | null;
+                historyPage: {
+                    offset: number;
+                    limit: number;
+                    total: number;
+                    nextOffset: number | null;
+                };
+                contextBudget: {
+                    maximumBytes: number;
+                    contentBytes: number;
+                    truncated: boolean;
+                    omitted: import("./app-spec.js").AppSpecDocumentSummary[];
+                };
+                stats: {
+                    files: number;
+                    bytes: number;
+                    capabilities: number;
+                    activeChanges: number;
+                    historyChanges: number;
+                    decisions: number;
+                    designs: number;
+                    requirements: number;
+                    acceptanceScenarios: number;
+                };
+                diagnostics: {
+                    errors: number;
+                    warnings: number;
+                    info: number;
+                };
+                nextCommand: string;
+            };
+        };
+        diagnostics: Diagnostic[];
+        nextActions: import("openxiangda-contracts").NextAction[];
+        traceId?: string;
+    }>;
+    deploymentStatus(root: string | undefined, deploymentId?: string): Promise<DevkitResult<undefined> | DevkitResult<DeploymentRun>>;
+    environmentStatus(root?: string): Promise<DevkitResult<import("openxiangda-contracts").ApplicationEnvironmentList>>;
+    startEnvironment(root: string | undefined, environment: DeploymentEnvironment, options?: {
+        idempotencyKey?: string;
+        requestId?: string;
+    }): Promise<DevkitResult<DeploymentRun>>;
+    stopEnvironment(root: string | undefined, environment: DeploymentEnvironment, options?: {
+        idempotencyKey?: string;
+        requestId?: string;
+    }): Promise<DevkitResult<DeploymentRun>>;
+    deploymentLogs(root: string | undefined, deploymentId?: string): Promise<{
+        operation: string;
+        ok: boolean;
+        workspace: WorkspaceIdentity;
+        data?: undefined;
+        diagnostics: Diagnostic[];
+        nextActions: import("openxiangda-contracts").NextAction[];
+        traceId?: string;
+    } | {
+        operation: string;
+        ok: boolean;
+        workspace: WorkspaceIdentity;
+        data?: DeploymentRun;
+        diagnostics: Diagnostic[];
+        nextActions: import("openxiangda-contracts").NextAction[];
+        traceId?: string;
+    } | {
         operation: string;
         data: {
             deploymentId: string;
@@ -192,6 +1110,11 @@ export declare class OpenXiangdaApplicationServices {
             stage: string;
             checkpoints: import("openxiangda-contracts").DeploymentCheckpoint[];
             failure: import("openxiangda-contracts").DeploymentFailure | undefined;
+            rootFailure: import("openxiangda-contracts").DeploymentFailure | null;
+            latestFailure: import("openxiangda-contracts").DeploymentFailure | null;
+            candidate: import("openxiangda-contracts").DeploymentCandidate;
+            recovery: import("openxiangda-contracts").DeploymentRecovery;
+            attempts: import("openxiangda-contracts").DeploymentAttempt[];
             traceId: unknown;
         };
         ok: boolean;
@@ -202,28 +1125,52 @@ export declare class OpenXiangdaApplicationServices {
     }>;
     retry(root: string | undefined, deploymentId: string): Promise<DevkitResult<DeploymentRun>>;
     cancel(root: string | undefined, deploymentId: string): Promise<DevkitResult<DeploymentRun>>;
-    promote(root: string | undefined, deploymentId: string, environment: "preproduction" | "production"): Promise<DevkitResult<DeploymentRun>>;
-    rollback(root: string | undefined, environment: "development" | "preproduction" | "production", appVersionId: string): Promise<DevkitResult<DeploymentRun>>;
-    doctor(root?: string): Promise<DevkitResult<{
-        commands: {
-            command: string;
-            ok: boolean;
-            version: string;
-        }[];
-        platform: Record<string, unknown>;
-    }>>;
-    dev(root?: string): Promise<DevkitResult<{
-        exitCode: number;
+    private deploymentRecoveryActions;
+    productionDeploymentPlan(root: string | undefined, deploymentId: string): Promise<DevkitResult<{
+        environment: string;
+        sourceDeploymentId: string;
+        appVersionId: string;
+        packageDigest: string;
+        sealed: boolean;
+        submitted: boolean;
+        rebuild: boolean;
+        businessAcceptance: string;
     }>>;
+    deployProduction(root: string | undefined, deploymentId: string): Promise<DevkitResult<undefined> | DevkitResult<DeploymentRun>>;
+    private productionPromotionDiagnostics;
+    rollback(root: string | undefined, environment: DeploymentEnvironment, appVersionId: string, options?: {
+        operationId?: string;
+    }): Promise<DevkitResult<DeploymentRun>>;
+    private deploymentEnvironment;
+    private changeEnvironmentRuntimeState;
+    dev(root?: string, input?: {
+        noOpen?: boolean;
+        /** @internal Used by the packaged browser verification harness. */
+        webPort?: number;
+        onStatus?: (message: string) => void;
+    }): Promise<DevkitResult<undefined> | DevkitResult<import("./connected-development.js").ConnectedDevelopmentResult>>;
     private workspace;
+    private appSpecContractIndex;
+    private validateTargetConfigurationCompatibility;
+    private configurationCompatibilityDiagnostic;
     private client;
     private get toolchainVersion();
+    private deliveryCacheContext;
+    private get toolchainCapsule();
+    private initializeBackend;
+    private packageScriptLabel;
     private runPackageScript;
+    private repositoryIdentity;
     private directoryBundle;
+    private writeCheckSealedArtifactStatus;
+    private sealedArtifactStatus;
+    private previousSealedArtifact;
+    private writeSealedArtifactStatus;
     private versionTrainDiagnostics;
+    private toolchainDiagnostics;
     private diagnostic;
+    private connectedDevelopmentFailure;
     private ok;
     private result;
 }
-export {};
 //# sourceMappingURL=application-services.d.ts.map