openxiangda-contracts 2.0.0-alpha.12

package/dist/types.d.ts

@@ -0,0 +1,1153 @@
+export declare const OPENXIANGDA_CONTRACT_VERSION: "2.0.0-alpha.1";
+export declare const SCHEMA_VERSIONS: {
+    readonly workspaceContext: "openxiangda.workspace-context/v2";
+    readonly application: "openxiangda.application/v2";
+    readonly applicationSecret: "openxiangda.application-secret/v2";
+    readonly diagnostic: "openxiangda.diagnostic/v2";
+    readonly principal: "openxiangda.principal/v2";
+    readonly roleAssignment: "openxiangda.role-assignment/v2";
+    readonly relationshipGrant: "openxiangda.relationship-grant/v2";
+    readonly roleSession: "openxiangda.role-session/v2";
+    readonly authorizationDecision: "openxiangda.authorization-decision/v2";
+    readonly authorizationBatchRequest: "openxiangda.authorization-batch-request/v2";
+    readonly authorizationBatchResult: "openxiangda.authorization-batch-result/v2";
+    readonly directoryResolveRequest: "openxiangda.directory-resolve-request/v2";
+    readonly directorySearchResult: "openxiangda.directory-search-result/v2";
+    readonly dataRef: "openxiangda.data-ref/v2";
+    readonly dataResource: "openxiangda.data-resource/v2";
+    readonly dataQuery: "openxiangda.data-query/v2";
+    readonly dataPage: "openxiangda.data-page/v2";
+    readonly dataRecord: "openxiangda.data-record/v2";
+    readonly dataAggregateQuery: "openxiangda.data-aggregate-query/v2";
+    readonly dataAggregatePage: "openxiangda.data-aggregate-page/v2";
+    readonly dataAuditPage: "openxiangda.data-audit-page/v2";
+    readonly dataFileRef: "openxiangda.data-file-ref/v2";
+    readonly dataFileUploadPlan: "openxiangda.data-file-upload-plan/v2";
+    readonly dataTransactionRequest: "openxiangda.data-transaction-request/v2";
+    readonly dataTransactionResult: "openxiangda.data-transaction-result/v2";
+    readonly cloudEvent: "openxiangda.cloud-event/v1";
+    readonly eventSubscription: "openxiangda.event-subscription/v2";
+    readonly eventDelivery: "openxiangda.event-delivery/v2";
+    readonly eventReceiptCommand: "openxiangda.event-receipt-command/v2";
+    readonly eventReceiptResult: "openxiangda.event-receipt-result/v2";
+    readonly timerSubscription: "openxiangda.timer-subscription/v2";
+    readonly workflowDefinition: "openxiangda.workflow-definition/v2";
+    readonly workflowBinding: "openxiangda.workflow-binding/v2";
+    readonly workflowPreparation: "openxiangda.workflow-preparation/v2";
+    readonly workflowInstance: "openxiangda.workflow-instance/v2";
+    readonly workflowTask: "openxiangda.workflow-task/v2";
+    readonly workflowSurface: "openxiangda.workflow-surface/v2";
+    readonly workflowDelegation: "openxiangda.workflow-delegation/v2";
+    readonly workflowAssigneeProvider: "openxiangda.workflow-assignee-provider/v2";
+    readonly workflowAssigneeRequest: "openxiangda.workflow-assignee-request/v2";
+    readonly workflowAssigneeResponse: "openxiangda.workflow-assignee-response/v2";
+    readonly workflowKernelDescriptor: "openxiangda.workflow-kernel-descriptor/v2";
+    readonly workflowKernelWorkItem: "openxiangda.workflow-kernel-work-item/v2";
+    readonly workflowKernelWorkCenter: "openxiangda.workflow-kernel-work-center/v2";
+    readonly appPackage: "openxiangda.app-package/v2";
+    readonly appVersion: "openxiangda.app-version/v2";
+    readonly environmentHead: "openxiangda.environment-head/v2";
+    readonly deploymentRun: "openxiangda.deployment-run/v2";
+    readonly platformCapabilities: "openxiangda.platform-capabilities/v2";
+};
+export type SchemaVersion = (typeof SCHEMA_VERSIONS)[keyof typeof SCHEMA_VERSIONS];
+export type Sha256Digest = string;
+export type IsoDateTime = string;
+export type DiagnosticSeverity = "info" | "warning" | "error";
+export interface Diagnostic {
+    schemaVersion: typeof SCHEMA_VERSIONS.diagnostic;
+    code: string;
+    severity: DiagnosticSeverity;
+    message: string;
+    path?: string;
+    source?: string;
+    retryable: boolean;
+    remediation?: string;
+    details?: Record<string, unknown>;
+}
+export interface WorkspaceIdentity {
+    appCode: string;
+    name?: string;
+    root: string;
+    repository?: string;
+    revision?: string;
+    dirty?: boolean;
+}
+export interface WorkspaceContext {
+    schemaVersion: typeof SCHEMA_VERSIONS.workspaceContext;
+    workspace: WorkspaceIdentity;
+    roots: {
+        frontend: string;
+        backend: string;
+        platform: string;
+    };
+    toolchain: {
+        version: string;
+        contractVersion: typeof OPENXIANGDA_CONTRACT_VERSION;
+        nodeVersion: string;
+        packageManager: string;
+    };
+    environments: Array<{
+        id?: string;
+        name: string;
+        kind: "development" | "preproduction" | "production";
+    }>;
+    changedDomains: Array<"frontend" | "backend" | "data" | "authz" | "events" | "workflow" | "config">;
+}
+export interface ProvisionedApplication {
+    schemaVersion: typeof SCHEMA_VERSIONS.application;
+    created: boolean;
+    application: {
+        id: string;
+        appCode: string;
+        name: string;
+        description?: string | null;
+        runtimeMode: "react-spa";
+        createdAt?: IsoDateTime | null;
+        updatedAt?: IsoDateTime | null;
+    };
+    bootstrapAdminRole: {
+        code: string;
+    };
+}
+export type PrincipalType = "user" | "service" | "public";
+export interface Principal {
+    schemaVersion: typeof SCHEMA_VERSIONS.principal;
+    tenantId: string;
+    appCode: string;
+    environmentId: string;
+    principalType: PrincipalType;
+    subjectId: string;
+    userId?: string;
+    loginSessionId?: string;
+    roleSessionId?: string;
+    activeRoleAssignmentId?: string;
+    activeRoleCode?: string;
+    authzVersion: number;
+    isAppSuperAdmin: boolean;
+}
+export interface OAuthApplicationPrincipal {
+    principalType: "application";
+    clientRecordId: string;
+    clientId: string;
+    credentialVersion: number;
+    tenantId: string;
+    appCode: string;
+    environmentKey: string;
+    scopes: string[];
+    rateLimitPerMinute: number;
+    tokenId: string;
+    issuedAt?: number;
+    expiresAt?: number;
+}
+export interface OAuthClient {
+    id: string;
+    appCode: string;
+    environmentKey: string;
+    name: string;
+    clientId: string;
+    clientKind: "external" | "runtime";
+    platformManaged: boolean;
+    clientSecretHint: string;
+    previousClientSecretHint?: string | null;
+    previousSecretValidUntil?: IsoDateTime | null;
+    pendingRotation?: {
+        credentialVersion: number;
+        requestedAt: IsoDateTime | null;
+        gracePeriodSeconds: number;
+    } | null;
+    scopes: string[];
+    status: "active" | "revoked";
+    credentialVersion: number;
+    rateLimitPerMinute: number;
+    lastUsedAt?: IsoDateTime | null;
+    lastRotatedAt?: IsoDateTime | null;
+    createdAt: IsoDateTime;
+    updatedAt: IsoDateTime;
+}
+export interface RuntimeOAuthCredentialStatus {
+    configured: boolean;
+    requiresRedeploy: boolean;
+    client: OAuthClient | null;
+    idempotentReplay?: boolean;
+}
+export interface OAuthAuditEvent {
+    id: string;
+    appCode: string | null;
+    environmentKey: string | null;
+    clientId: string | null;
+    eventType: string;
+    outcome: "allowed" | "denied";
+    actorType: "user" | "application" | "anonymous";
+    actorId: string | null;
+    tokenId: string | null;
+    requestId: string | null;
+    ipAddress: string | null;
+    reasonCode: string | null;
+    details: Record<string, unknown>;
+    createdAt: IsoDateTime;
+}
+export interface ApplicationSecret {
+    schemaVersion: typeof SCHEMA_VERSIONS.applicationSecret;
+    id: string;
+    appCode: string;
+    environmentKey: string;
+    name: string;
+    description: string | null;
+    status: "active" | "disabled" | "deleted";
+    revision: number;
+    hasValue: boolean;
+    expiresAt: IsoDateTime | null;
+    createdAt: IsoDateTime;
+    updatedAt: IsoDateTime;
+    idempotentReplay?: boolean;
+    references?: {
+        activeConfiguration: {
+            appVersionId: string;
+            version: string;
+            configDigest: string;
+        } | null;
+    };
+}
+export interface ApplicationSecretAuditEvent {
+    schemaVersion: typeof SCHEMA_VERSIONS.applicationSecret;
+    id: string;
+    appCode: string;
+    environmentKey: string;
+    name: string;
+    eventType: string;
+    outcome: "allowed" | "denied";
+    actorUserId: string | null;
+    version: number | null;
+    revision: number | null;
+    reason: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: IsoDateTime;
+}
+export interface RoleSession {
+    schemaVersion: typeof SCHEMA_VERSIONS.roleSession;
+    id: string;
+    loginSessionId: string;
+    tenantId: string;
+    appCode: string;
+    userId: string;
+    activeRoleAssignmentId: string;
+    activeRoleCode: string;
+    authzVersion: number;
+    issuedAt: IsoDateTime;
+    expiresAt: IsoDateTime;
+    lastUsedAt: IsoDateTime;
+}
+export interface RoleAssignmentScopeGrant {
+    dimensionCode: string;
+    values: string[];
+    operations: string[];
+}
+export interface ApplicationRole {
+    id: string;
+    appCode: string;
+    code: string;
+    name: string;
+    description?: string | null;
+    isAppSuperAdmin: boolean;
+}
+export interface RoleAssignment {
+    schemaVersion: typeof SCHEMA_VERSIONS.roleAssignment;
+    id: string;
+    tenantId: string;
+    appCode: string;
+    userId: string;
+    role: {
+        id: string;
+        code: string;
+        name: string;
+        isAppSuperAdmin: boolean;
+    };
+    status: "active" | "revoked" | "expired";
+    revision: number;
+    scopeGrants: RoleAssignmentScopeGrant[];
+    validFrom?: IsoDateTime | null;
+    validTo?: IsoDateTime | null;
+    createdAt: IsoDateTime;
+    updatedAt: IsoDateTime;
+}
+export type RelationshipGrantSubjectType = "user" | "role_assignment";
+export type RelationshipGrantStatus = "active" | "revoked" | "expired";
+export interface RelationshipGrant {
+    schemaVersion: typeof SCHEMA_VERSIONS.relationshipGrant;
+    id: string;
+    tenantId: string;
+    appCode: string;
+    relationCode: string;
+    subjectType: RelationshipGrantSubjectType;
+    subjectKey: string;
+    resourceCode: string;
+    resourceId: string;
+    operations: string[];
+    sourceCode: string;
+    status: RelationshipGrantStatus;
+    revision: number;
+    validFrom?: IsoDateTime | null;
+    validTo?: IsoDateTime | null;
+    createdAt: IsoDateTime;
+    updatedAt: IsoDateTime;
+}
+export interface AuthorizationDecisionLayer {
+    layer: "app_super_admin" | "rbac" | "data_policy" | "field_policy";
+    allowed: boolean;
+    reason?: string;
+    detail?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface AuthorizationDecision {
+    schemaVersion: typeof SCHEMA_VERSIONS.authorizationDecision;
+    explainId: string;
+    allowed: boolean;
+    principal: Principal;
+    roleSession: RoleSession;
+    decisions: AuthorizationDecisionLayer[];
+}
+export interface AuthorizationExplainRequest {
+    key: string;
+    capability: string;
+    dataPolicyCode?: string;
+    operation?: string;
+    data?: Record<string, unknown>;
+}
+export interface AuthorizationBatchRequest {
+    schemaVersion: typeof SCHEMA_VERSIONS.authorizationBatchRequest;
+    requests: AuthorizationExplainRequest[];
+}
+export interface AuthorizationBatchResult {
+    schemaVersion: typeof SCHEMA_VERSIONS.authorizationBatchResult;
+    principal: Principal;
+    roleSession: RoleSession;
+    items: Array<{
+        key: string;
+        decision: AuthorizationDecision;
+    }>;
+}
+export type DirectoryEntryKind = "department" | "user";
+export interface DirectoryEntry {
+    kind: DirectoryEntryKind;
+    id: string;
+    label: string;
+    description?: string;
+    path?: Array<{
+        id: string;
+        label: string;
+    }>;
+}
+export interface DirectoryResolveRequest {
+    schemaVersion: typeof SCHEMA_VERSIONS.directoryResolveRequest;
+    kind: DirectoryEntryKind;
+    ids: string[];
+}
+export interface DirectorySearchResult {
+    schemaVersion: typeof SCHEMA_VERSIONS.directorySearchResult;
+    kind: DirectoryEntryKind;
+    items: DirectoryEntry[];
+    total: number;
+}
+export interface DataRef {
+    schemaVersion: typeof SCHEMA_VERSIONS.dataRef;
+    appCode: string;
+    resource: string;
+    recordId: string;
+    revision: number;
+    environmentId?: string;
+}
+export type DataFieldType = "string" | "text" | "integer" | "decimal" | "boolean" | "date" | "datetime" | "uuid" | "json" | "file";
+export interface DataFieldDefinition {
+    code: string;
+    type: DataFieldType;
+    nullable?: boolean;
+    indexed?: boolean;
+    file?: {
+        multiple?: boolean;
+        maxCount?: number;
+        maxSizeMb?: number;
+        accept?: string[];
+    };
+}
+export interface DataFieldPolicy {
+    read?: string[];
+    write?: string[];
+    mask?: "omit" | "null";
+}
+export interface DataResource {
+    schemaVersion: typeof SCHEMA_VERSIONS.dataResource;
+    id?: string;
+    tenantId?: string;
+    appCode: string;
+    code: string;
+    name: string;
+    schema: {
+        fields: DataFieldDefinition[];
+    };
+    capabilities: {
+        read: string;
+        create: string;
+        update: string;
+        delete: string;
+    };
+    dataPolicyCode?: string | null;
+    fieldPolicies: Record<string, DataFieldPolicy>;
+    status?: "active" | "retired";
+    revision?: number;
+    createdAt?: IsoDateTime;
+    updatedAt?: IsoDateTime;
+}
+export type DataFilterOperator = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "like" | "ilike" | "in" | "is" | "cs" | "cd" | "ov";
+export interface DataQuery {
+    schemaVersion: typeof SCHEMA_VERSIONS.dataQuery;
+    select?: string[];
+    filters?: Array<{
+        field: string;
+        operator: DataFilterOperator;
+        value: unknown;
+    }>;
+    order?: Array<{
+        field: string;
+        direction?: "asc" | "desc";
+        nulls?: "first" | "last";
+    }>;
+    limit?: number;
+    offset?: number;
+}
+export interface DataPage<T extends Record<string, unknown> = Record<string, unknown>> {
+    schemaVersion: typeof SCHEMA_VERSIONS.dataPage;
+    resourceCode: string;
+    items: T[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+export interface DataRecord<T extends Record<string, unknown> = Record<string, unknown>> {
+    schemaVersion: typeof SCHEMA_VERSIONS.dataRecord;
+    resourceCode: string;
+    data: T;
+}
+export type DataAggregateMeasureType = "count" | "countDistinct" | "sum" | "avg" | "min" | "max";
+export interface DataAggregateQuery {
+    schemaVersion: typeof SCHEMA_VERSIONS.dataAggregateQuery;
+    dimensions?: Array<{
+        field: string;
+        as: string;
+        bucket?: "day" | "week" | "month" | "quarter" | "year";
+    }>;
+    measures: Array<{
+        type: DataAggregateMeasureType;
+        field?: string;
+        as: string;
+    }>;
+    filters?: DataQuery["filters"];
+    order?: Array<{
+        field: string;
+        direction?: "asc" | "desc";
+        nulls?: "first" | "last";
+    }>;
+    limit?: number;
+    offset?: number;
+}
+export interface DataAggregatePage<T extends Record<string, unknown> = Record<string, unknown>> {
+    schemaVersion: typeof SCHEMA_VERSIONS.dataAggregatePage;
+    resourceCode: string;
+    items: T[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+export interface DataAuditEntry {
+    id: string;
+    operation: "created" | "updated" | "deleted";
+    recordId: string;
+    revision: number;
+    actor: {
+        userId: string;
+        roleSessionId?: string | null;
+        principalType?: "user" | "application";
+        oauthClientId?: string | null;
+    };
+    correlation?: {
+        eventId: string;
+        requestId: string | null;
+        traceId: string | null;
+        environmentKey: string;
+        outboxStatus: string;
+        outboxAttempts: number;
+        outboxError: string | null;
+        outboxUpdatedAt: IsoDateTime | null;
+    };
+    changes?: Record<string, unknown>;
+    before?: Record<string, unknown>;
+    record?: Record<string, unknown>;
+    occurredAt: IsoDateTime;
+}
+export interface DataAuditPage {
+    schemaVersion: typeof SCHEMA_VERSIONS.dataAuditPage;
+    resourceCode: string;
+    recordId: string;
+    items: DataAuditEntry[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+export interface DataFileRef {
+    schemaVersion: typeof SCHEMA_VERSIONS.dataFileRef;
+    id: string;
+    name: string;
+    size: number;
+    contentType: string;
+}
+export interface DataFileUploadPlan {
+    schemaVersion: typeof SCHEMA_VERSIONS.dataFileUploadPlan;
+    resourceCode: string;
+    fieldCode: string;
+    file: DataFileRef;
+    uploadMethod: "PUT";
+    uploadUrl: string;
+    headers: Record<string, string>;
+    expiresAt: IsoDateTime;
+}
+export type DataTransactionOperation = {
+    operation: "create";
+    resourceCode: string;
+    data: Record<string, unknown>;
+} | {
+    operation: "update";
+    resourceCode: string;
+    id: string;
+    expectedRevision: number;
+    data: Record<string, unknown>;
+} | {
+    operation: "delete";
+    resourceCode: string;
+    id: string;
+    expectedRevision: number;
+};
+export interface DataTransactionRequest {
+    schemaVersion: typeof SCHEMA_VERSIONS.dataTransactionRequest;
+    idempotencyKey: string;
+    operations: DataTransactionOperation[];
+}
+export interface DataTransactionResult {
+    schemaVersion: typeof SCHEMA_VERSIONS.dataTransactionResult;
+    idempotencyKey: string;
+    replayed: boolean;
+    items: Array<{
+        index: number;
+        resourceCode: string;
+        operation: "create" | "update" | "delete";
+        id: string;
+        revision: number;
+    }>;
+}
+export interface CloudEvent<TData extends Record<string, unknown> = Record<string, unknown>> {
+    specversion: "1.0";
+    id: string;
+    source: string;
+    type: string;
+    subject?: string;
+    time: IsoDateTime;
+    datacontenttype: "application/json";
+    dataschema?: string;
+    data: TData;
+    tenantid: string;
+    appcode: string;
+    environment: string;
+    traceid?: string;
+    schemaversion: string;
+}
+export interface EventSubscription {
+    schemaVersion: typeof SCHEMA_VERSIONS.eventSubscription;
+    id: string;
+    appCode: string;
+    code: string;
+    description: string | null;
+    eventTypes: string[];
+    subjectFilters: {
+        equals?: string;
+        prefix?: string;
+        suffix?: string;
+        contains?: string | string[];
+    };
+    environmentKey: string;
+    endpointPath: string;
+    delivery: {
+        timeoutMs: number;
+        maxAttempts: number;
+        initialBackoffMs: number;
+        maxBackoffMs: number;
+    };
+    status: "active" | "paused";
+    revision: number;
+    signingSecret?: string;
+    signingSecretVersion?: number;
+    pendingSigningSecretVersion?: number | null;
+    rotationPending?: boolean;
+    previousSigningSecretVersion?: number | null;
+    previousSigningSecretValidUntil?: IsoDateTime | null;
+    signingSecretReturnedOnce?: boolean;
+    createdAt: IsoDateTime;
+    updatedAt: IsoDateTime;
+}
+export interface EventDelivery {
+    schemaVersion: typeof SCHEMA_VERSIONS.eventDelivery;
+    id: string;
+    eventId: string;
+    eventType: string;
+    subject: string | null;
+    subscriptionId: string;
+    subscriptionCode: string;
+    status: "pending" | "delivering" | "retry_wait" | "succeeded" | "dead_lettered";
+    attempt: number;
+    nextAttemptAt: IsoDateTime | null;
+    deliveredAt: IsoDateTime | null;
+    responseStatus: number | null;
+    responseBodyPreview: string | null;
+    lastError: string | null;
+    replayOfDeliveryId: string | null;
+    correlation?: {
+        eventId: string;
+        requestId: string | null;
+        traceId: string | null;
+        environmentKey: string;
+        eventOccurredAt: IsoDateTime | null;
+        outboxStatus: string | null;
+        outboxAttempts: number;
+        outboxError: string | null;
+    };
+    createdAt: IsoDateTime;
+    updatedAt: IsoDateTime;
+}
+export interface EventReceiptCommand {
+    schemaVersion: typeof SCHEMA_VERSIONS.eventReceiptCommand;
+    action: "claim" | "complete" | "release";
+    tenantId: string;
+    appCode: string;
+    environmentKey: string;
+    subscriptionCode: string;
+    eventId: string;
+    deliveryId: string;
+    claimToken?: string;
+}
+export interface EventReceiptResult {
+    schemaVersion: typeof SCHEMA_VERSIONS.eventReceiptResult;
+    outcome: "claimed" | "duplicate" | "completed" | "released";
+    eventId: string;
+    deliveryId: string;
+    status: "processing" | "succeeded" | "released";
+    claimToken: string | null;
+    attempts: number;
+    leaseExpiresAt: IsoDateTime;
+    completedAt: IsoDateTime | null;
+}
+export interface TimerSubscription {
+    schemaVersion: typeof SCHEMA_VERSIONS.timerSubscription;
+    id: string;
+    appCode: string;
+    code: string;
+    eventType: string;
+    cronExpression: string;
+    timezone: string;
+    payload: Record<string, unknown>;
+    environmentKey: string;
+    status: "active" | "paused";
+    revision: number;
+    nextDueAt: IsoDateTime | null;
+    lastFiredAt: IsoDateTime | null;
+    createdAt: IsoDateTime;
+    updatedAt: IsoDateTime;
+}
+export type WorkflowApprovalMode = "single" | "any" | "all" | "sequence";
+export type WorkflowFieldPolicy = "hidden" | "readonly" | "edit" | "edit_required";
+export type WorkflowCommand = "approve" | "reject" | "return" | "transfer" | "delegate" | "add_assignee" | "resubmit" | "withdraw" | "terminate" | "admin_reassign" | "admin_override" | "retry_resolution";
+export type WorkflowExpression = {
+    op: "literal";
+    value: unknown;
+} | {
+    op: "path";
+    path: string;
+} | {
+    op: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "contains";
+    left: WorkflowExpression;
+    right: WorkflowExpression;
+} | {
+    op: "and" | "or";
+    values: WorkflowExpression[];
+} | {
+    op: "not" | "exists";
+    value: WorkflowExpression;
+};
+export interface WorkflowApprovalNode {
+    id: string;
+    kind: "approval";
+    title: string;
+    binding: string;
+    mode: WorkflowApprovalMode;
+    onApprove: string;
+    onReject: string;
+    allowedOperations?: WorkflowCommand[];
+    returnTargets?: string[];
+    fieldPolicy?: {
+        default?: WorkflowFieldPolicy;
+        fields?: Record<string, WorkflowFieldPolicy>;
+    };
+}
+export interface WorkflowConditionNode {
+    id: string;
+    kind: "condition";
+    title?: string;
+    branches: Array<{
+        when: WorkflowExpression;
+        target: string;
+        label?: string;
+    }>;
+    otherwise: string;
+}
+export interface WorkflowEndNode {
+    id: string;
+    kind: "end";
+    title: string;
+    outcome: string;
+}
+export type WorkflowNode = WorkflowApprovalNode | WorkflowConditionNode | WorkflowEndNode;
+export interface WorkflowDefinition {
+    schemaVersion: typeof SCHEMA_VERSIONS.workflowDefinition;
+    code: string;
+    title: string;
+    startAt: string;
+    inputSchema: Record<string, unknown>;
+    organizationContext?: {
+        department?: {
+            source: "none" | "user_primary_department" | "choose_if_multiple" | "always_choose" | "fixed" | "from_input" | "from_role_scope";
+            required?: boolean;
+            value?: string;
+            path?: string;
+            /** Scope dimension used by from_role_scope; defaults to `department`. */
+            dimension?: string;
+        };
+    };
+    nodes: Record<string, WorkflowNode>;
+}
+export type WorkflowBindingProvider = "fixed_users" | "initiator" | "input_users" | "form_field_users" | "department_supervisor" | "app_role" | "app_role_in_scope" | "business_relation" | "previous_node_actor" | "initiator_select" | "application_provider";
+export interface WorkflowBindingEntry {
+    provider: WorkflowBindingProvider;
+    users?: string[];
+    inputPath?: string;
+    departmentIdFrom?: string;
+    level?: number;
+    fallbackToAncestorSupervisor?: boolean;
+    roleCode?: string;
+    scope?: {
+        dimension: string;
+        valueFrom?: string;
+        value?: string;
+    };
+    relationCode?: string;
+    resourceCode?: string;
+    resourceIdFrom?: string;
+    providerCode?: string;
+    min?: number;
+    max?: number;
+}
+export interface WorkflowBinding {
+    schemaVersion: typeof SCHEMA_VERSIONS.workflowBinding;
+    workflowCode: string;
+    bindings: Record<string, WorkflowBindingEntry>;
+}
+export interface WorkflowCandidatePrincipal {
+    userId: string;
+    roleAssignmentId?: string;
+    roleCode?: string;
+    displayName?: string;
+    source: string;
+}
+export interface WorkflowPreparationOption {
+    value: string;
+    label: string;
+    description?: string;
+}
+export type WorkflowPreparationRequirement = {
+    id: string;
+    kind: "choose_department";
+    title: string;
+    required: boolean;
+    candidates: WorkflowPreparationOption[];
+} | {
+    id: string;
+    kind: "choose_approvers";
+    title: string;
+    required: boolean;
+    min: number;
+    max: number;
+    candidates: WorkflowCandidatePrincipal[];
+} | {
+    id: string;
+    kind: string;
+    title: string;
+    required?: boolean;
+    candidates?: Array<WorkflowPreparationOption | WorkflowCandidatePrincipal>;
+    min?: number;
+    max?: number;
+    inputSchema?: Record<string, unknown>;
+    uiSchema?: Record<string, unknown>;
+};
+export interface WorkflowPreviewNode {
+    nodeId: string;
+    kind: WorkflowNode["kind"];
+    title?: string;
+    result?: Record<string, unknown>;
+    assignees: WorkflowCandidatePrincipal[];
+    assignmentExplain: Array<Record<string, unknown>>;
+}
+export interface WorkflowPreparation {
+    schemaVersion: typeof SCHEMA_VERSIONS.workflowPreparation;
+    preparationId: string;
+    status: "needs_input" | "ready";
+    requirements: WorkflowPreparationRequirement[];
+    preparationToken: string | null;
+    preview: {
+        certainty: "partial" | "complete";
+        nodes: WorkflowPreviewNode[];
+        outcome: string | null;
+        warnings: Array<Record<string, unknown>>;
+    };
+    expiresAt: IsoDateTime;
+    definitionVersion: number;
+    bindingVersion: number;
+    inputHash: Sha256Digest;
+}
+export interface WorkflowInstance {
+    schemaVersion: typeof SCHEMA_VERSIONS.workflowInstance;
+    engineVersion: "2.0";
+    id: string;
+    appCode: string;
+    environmentKey: string;
+    workflowCode: string;
+    definitionVersion: number;
+    bindingVersion: number;
+    businessKey: string;
+    generation: number;
+    status: "running" | "returned" | "approved" | "rejected" | "withdrawn" | "terminated" | "error";
+    initiatorUserId: string;
+    initiatorRoleAssignmentId: string;
+    dataRef: Record<string, unknown>;
+    dataRevision: string;
+    currentNodeId: string | null;
+    outcome: string | null;
+    version: number;
+    startedAt: IsoDateTime;
+    completedAt: IsoDateTime | null;
+}
+export interface WorkflowTask {
+    schemaVersion: typeof SCHEMA_VERSIONS.workflowTask;
+    engineVersion: "2.0";
+    id: string;
+    instanceId: string;
+    workflowCode: string;
+    businessKey: string;
+    nodeId: string;
+    title: string;
+    status: "assignment_pending" | "assigned" | "completed" | "rejected" | "returned" | "cancelled" | "expired";
+    approvalMode: WorkflowApprovalMode;
+    taskKind: "normal" | "return_review" | "resume";
+    originTaskId: string | null;
+    returnSessionId: string | null;
+    version: number;
+    dataRef: Record<string, unknown>;
+    createdAt: IsoDateTime;
+    updatedAt: IsoDateTime;
+}
+export interface WorkflowOperationSurface {
+    key: WorkflowCommand | string;
+    kind: "workflow_command" | "app_action";
+    label: string;
+    placement: "primary" | "secondary" | string;
+    tone: string;
+    visible: boolean;
+    enabled: boolean;
+    disabledReason?: string;
+    inputSchema: Record<string, unknown>;
+    uiSchema: Record<string, unknown>;
+    execute: {
+        method: "POST";
+        href: string;
+        idempotencyRequired: boolean;
+    };
+    refresh: string[];
+}
+export interface WorkflowSurface {
+    schemaVersion: typeof SCHEMA_VERSIONS.workflowSurface;
+    protocolVersion: "workflow_surface_v2";
+    surfaceRevision: Sha256Digest;
+    engineVersion: "2.0";
+    instance: WorkflowInstance | Record<string, unknown>;
+    task: WorkflowTask | Record<string, unknown> | null;
+    presentation: Record<string, unknown>;
+    fieldPolicy: {
+        default: WorkflowFieldPolicy;
+        fields: Record<string, WorkflowFieldPolicy>;
+    };
+    operations: WorkflowOperationSurface[];
+    extensions: Record<string, unknown>;
+}
+export interface WorkflowDelegation {
+    schemaVersion: typeof SCHEMA_VERSIONS.workflowDelegation;
+    id: string;
+    appCode: string;
+    workflowCode: string | null;
+    delegatorUserId: string;
+    delegateUserId: string;
+    delegatorRoleAssignmentId: string;
+    delegateRoleAssignmentId: string;
+    validFrom: IsoDateTime;
+    validTo: IsoDateTime;
+    status: "active" | "revoked" | "expired";
+    reason: string;
+    createdBy: string;
+    createdAt: IsoDateTime;
+    revokedAt: IsoDateTime | null;
+}
+export interface WorkflowDelegationTarget {
+    roleAssignmentId: string;
+    userId: string;
+    role: {
+        code: string;
+        name: string;
+        isAppSuperAdmin: boolean;
+    };
+    scopeGrants: RoleAssignmentScopeGrant[];
+    validFrom: IsoDateTime | null;
+    validTo: IsoDateTime | null;
+}
+export interface WorkflowAssigneeProvider {
+    schemaVersion: typeof SCHEMA_VERSIONS.workflowAssigneeProvider;
+    id: string;
+    appCode: string;
+    environmentKey: string;
+    code: string;
+    endpointPath: string;
+    timeoutMs: number;
+    status: "active" | "paused";
+    signingSecretVersion: number;
+    pendingSigningSecretVersion: number | null;
+    rotationPending: boolean;
+    revision: number;
+    signingSecret?: string | null;
+    signingSecretReturnedOnce?: boolean;
+    createdAt: IsoDateTime;
+    updatedAt: IsoDateTime;
+}
+export interface WorkflowAssigneeRequest {
+    schemaVersion: typeof SCHEMA_VERSIONS.workflowAssigneeRequest;
+    requestId: string;
+    providerCode: string;
+    appCode: string;
+    environmentKey: string;
+    workflowCode: string;
+    nodeId: string;
+    facts: Record<string, unknown>;
+    organizationContext: Record<string, unknown>;
+    initiator: WorkflowCandidatePrincipal;
+    authzVersion: number;
+}
+export interface WorkflowAssigneeResponse {
+    schemaVersion: typeof SCHEMA_VERSIONS.workflowAssigneeResponse;
+    requestId: string;
+    candidates: WorkflowCandidatePrincipal[];
+}
+export interface WorkflowKernelDescriptor {
+    schemaVersion: typeof SCHEMA_VERSIONS.workflowKernelDescriptor;
+    engineVersion: "2.0";
+    instanceId: string;
+    appCode: string;
+    status: string;
+    businessKey: string | null;
+    routes: Record<string, string>;
+    authorizationMode: "role_session_v2";
+}
+export interface WorkflowKernelWorkItem {
+    schemaVersion: typeof SCHEMA_VERSIONS.workflowKernelWorkItem;
+    engineVersion: "2.0";
+    appCode: string;
+    instanceId: string;
+    taskId: string | null;
+    workflowCode: string | null;
+    businessKey: string | null;
+    status: string;
+    nodeId: string | null;
+    title: string | null;
+    dataRef: Record<string, unknown> | null;
+    updatedAt: IsoDateTime;
+    startedAt: IsoDateTime;
+    descriptorHref: string;
+    surfaceHref: string;
+    authorizationMode: "role_session_v2";
+}
+export interface WorkflowKernelWorkCenter {
+    schemaVersion: typeof SCHEMA_VERSIONS.workflowKernelWorkCenter;
+    category: "pending" | "completed" | "created";
+    roleSessionId: string;
+    activeRoleAssignmentId: string;
+    items: WorkflowKernelWorkItem[];
+    engineCounts: {
+        "2.0"?: number;
+    };
+}
+export type AppArtifactKind = "frontend" | "backend" | "config" | "contracts";
+export interface AppArtifact {
+    kind: AppArtifactKind;
+    digest: Sha256Digest;
+    mediaType: string;
+    size?: number;
+    entrypoint?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AppPackage {
+    schemaVersion: typeof SCHEMA_VERSIONS.appPackage;
+    appCode: string;
+    version: string;
+    createdAt: IsoDateTime;
+    source: {
+        repository: string;
+        commit: string;
+        dirty: boolean;
+    };
+    toolchain: {
+        version: string;
+        contractVersion: typeof OPENXIANGDA_CONTRACT_VERSION;
+    };
+    artifacts: AppArtifact[];
+    manifests: {
+        frontend?: Sha256Digest;
+        backend?: Sha256Digest;
+        config?: Sha256Digest;
+        dataContract?: Sha256Digest;
+    };
+    compatibility: {
+        minimumPlatformVersion: string;
+        requiredCapabilities: string[];
+    };
+    metadata?: Record<string, unknown>;
+}
+export interface AppVersion {
+    schemaVersion: typeof SCHEMA_VERSIONS.appVersion;
+    id: string;
+    appCode: string;
+    version: string;
+    packageDigest: Sha256Digest;
+    source: AppPackage["source"];
+    toolchain: AppPackage["toolchain"];
+    revisions: {
+        frontend: string | null;
+        backend: string | null;
+        config: string | null;
+        dataContract: string | null;
+    };
+    metadata: Record<string, unknown>;
+    createdBy: string;
+    createdAt: IsoDateTime;
+}
+export interface EnvironmentHead {
+    schemaVersion: typeof SCHEMA_VERSIONS.environmentHead;
+    id: string;
+    appCode: string;
+    environmentKey: string;
+    environmentId: string | null;
+    environmentKind: "development" | "preproduction" | "production";
+    activeAppVersionId: string;
+    revisions: AppVersion["revisions"];
+    revision: number;
+    activatedByDeploymentId: string;
+    activatedBy: string;
+    activatedAt: IsoDateTime;
+    updatedAt: IsoDateTime;
+    activeAppVersion?: AppVersion | null;
+}
+export type DeploymentKind = "deploy" | "promotion" | "rollback";
+export type DeploymentStatus = "queued" | "preparing" | "deploying" | "activating" | "verifying" | "succeeded" | "failed" | "cancelled";
+export interface DeploymentCheckpoint {
+    stage: string;
+    status: DeploymentStatus;
+    at: IsoDateTime;
+    attempt: number;
+    component?: string;
+    result?: Record<string, unknown>;
+}
+export interface DeploymentFailure {
+    code: string;
+    message: string;
+    retryable: boolean;
+    stage?: string;
+    component?: string;
+    details?: Record<string, unknown>;
+}
+export interface DeploymentRun {
+    schemaVersion: typeof SCHEMA_VERSIONS.deploymentRun;
+    id: string;
+    appCode: string;
+    environment: {
+        id?: string;
+        kind?: "development" | "preproduction" | "production";
+    };
+    kind: DeploymentKind;
+    packageDigest: Sha256Digest;
+    idempotencyKey: string;
+    status: DeploymentStatus;
+    stage: string;
+    attempt: number;
+    progress: Record<string, unknown>;
+    checkpoints: DeploymentCheckpoint[];
+    failure?: DeploymentFailure;
+    result: Record<string, unknown>;
+    requestedBy: string;
+    startedAt?: IsoDateTime;
+    finishedAt?: IsoDateTime;
+    createdAt: IsoDateTime;
+    updatedAt: IsoDateTime;
+}
+export interface PlatformCapabilities {
+    schemaVersion: typeof SCHEMA_VERSIONS.platformCapabilities;
+    apiVersion: "v2";
+    contractVersion: typeof OPENXIANGDA_CONTRACT_VERSION;
+    platformVersion: string;
+    features: Record<string, {
+        version: string;
+        status: "available" | "preview" | "planned";
+    }>;
+    deployment: {
+        executionOwner: "platform";
+        durableRuns: true;
+        clientCanCheckpoint: false;
+    };
+    oauth2?: {
+        tokenEndpoint: string;
+        grantTypes: ["client_credentials"];
+        clientAuthenticationMethods: ["client_secret_basic"];
+        accessTokenTtlSeconds: number;
+        supportedScopes: string[];
+        environmentBoundClients: boolean;
+        dualSecretRotation: boolean;
+        defaultRotationGracePeriodSeconds: number;
+        clientRateLimit: boolean;
+        auditEvents: boolean;
+    };
+}
+export interface NextAction {
+    code: string;
+    label: string;
+    command?: string;
+    href?: string;
+}
+export interface DevkitResult<T> {
+    ok: boolean;
+    operation: string;
+    workspace: WorkspaceIdentity;
+    data?: T;
+    diagnostics: Diagnostic[];
+    nextActions: NextAction[];
+    traceId?: string;
+}
+//# sourceMappingURL=types.d.ts.map