import type { JsonObject } from "../state/json.js";
import type { JsonPatch } from "../workflows/json-patch.js";
export type { JsonPrimitive, JsonValue, JsonObject } from "../state/json.js";
export type MaybePromise<T> = T | Promise<T>;
export type ManagedResourceConditionStatus = true | false | "unknown";
export type ManagedResourceCondition = {
    type: string;
    status: ManagedResourceConditionStatus;
    reason: string;
    message?: string;
    observedGeneration: number;
    lastTransitionTime: string;
};
export type ChildWorkflowState = "pending" | "running" | "waiting" | "succeeded" | "failed" | "interrupted";
export type ChildWorkflowReference = {
    requestId: string;
    runId?: string;
    state: ChildWorkflowState;
    attempt: number;
};
export type ManagedResourceStatus<TStatus> = {
    observedGeneration: number;
    conditions: ManagedResourceCondition[];
    resourceManagerStatus: TStatus;
    workflowRun?: ChildWorkflowReference;
};
export type ManagedResource<TSpec = unknown, TStatus = unknown> = {
    metadata: {
        uid: string;
        resourceManager: string;
        key: string;
        resourceVersion: number;
        generation: number;
        deletionTimestamp?: string;
        finalizers: string[];
    };
    spec: TSpec;
    status: ManagedResourceStatus<TStatus>;
};
export type ManagedResourceRef = {
    resourceManager: string;
    key: string;
};
export type ManagedResourceConditionInput = {
    type: string;
    status: ManagedResourceConditionStatus;
    reason: string;
    message?: string;
};
export type ResourceManagerStatusPatch<TStatus> = {
    resourceManagerStatus?: TStatus;
    conditions?: ManagedResourceConditionInput[];
    workflowRun?: ChildWorkflowReference | null;
    finalizers?: string[];
};
export type ReconcileResult<TStatus> = {
    kind: "settled";
    status?: ResourceManagerStatusPatch<TStatus>;
} | {
    kind: "requeue";
    afterMs?: number;
    status?: ResourceManagerStatusPatch<TStatus>;
};
export type EffectState = "pending" | "applied" | "rejected" | "indeterminate";
export type EffectRecord = {
    key: string;
    resourceUid: string;
    generation: number;
    kind: string;
    state: EffectState;
    requestFingerprint: string;
    startedAt: string;
    completedAt?: string;
    externalRef?: string;
    error?: string;
};
export type EffectObservation = {
    state: "applied";
    externalRef?: string;
} | {
    state: "not_applied";
} | {
    state: "indeterminate";
};
export type EffectApplication = {
    state: "applied";
    externalRef?: string;
} | {
    state: "rejected";
    error: string;
} | {
    state: "indeterminate";
    error?: string;
};
export type EffectDefinition<TRequest> = {
    key: string;
    kind: string;
    request: TRequest;
    observe: (signal: AbortSignal) => MaybePromise<EffectObservation>;
    apply: (signal: AbortSignal) => MaybePromise<EffectApplication>;
};
export interface ResourceManagerEffects {
    ensure<TRequest>(definition: EffectDefinition<TRequest>): Promise<EffectRecord>;
}
export type ChildWorkflowRequest = {
    requestKey: string;
    workflow: string;
    input: unknown;
};
export type ChildWorkflowRecord = ChildWorkflowReference & {
    resourceUid: string;
    requestKey: string;
    inputFingerprint: string;
    workflow: string;
    error?: string;
};
export type ResourceManagerSettingsChangeRequest = {
    requestKey: string;
    runId: string;
    scopeId?: string;
    expectedChangeNumber?: number;
    patch: JsonPatch;
};
export type ResourceManagerSettingsChangeResult = {
    runId: string;
    scopeId: string;
    changeNumber: number;
    adopted: boolean;
};
export type ResourceManagerQueueFollowUpRequest = {
    requestKey: string;
    runId: string;
    prompt: string;
};
export type ResourceManagerFollowUpResult = {
    runId: string;
    followUpId: string;
    order: number;
    state: string;
    adopted: boolean;
};
export type ResourceManagerRemoveFollowUpRequest = {
    requestKey: string;
    runId: string;
    followUpId: string;
};
export interface ResourceManagerWorkflows {
    ensure(request: ChildWorkflowRequest): Promise<ChildWorkflowRecord>;
    changeSettings(request: ResourceManagerSettingsChangeRequest): Promise<ResourceManagerSettingsChangeResult>;
    queueFollowUp(request: ResourceManagerQueueFollowUpRequest): Promise<ResourceManagerFollowUpResult>;
    removeFollowUp(request: ResourceManagerRemoveFollowUpRequest): Promise<ResourceManagerFollowUpResult>;
}
export type ReconcileContext<TStatus> = {
    signal: AbortSignal;
    effects: ResourceManagerEffects;
    workflows: ResourceManagerWorkflows;
    settled(status?: ResourceManagerStatusPatch<TStatus>): ReconcileResult<TStatus>;
    requeue(status?: ResourceManagerStatusPatch<TStatus>): ReconcileResult<TStatus>;
    requeueAfter(afterMs: number, status?: ResourceManagerStatusPatch<TStatus>): ReconcileResult<TStatus>;
};
export type ResourceManagerDefinition<TSpec = unknown, TStatus = unknown> = {
    name: string;
    initialStatus: (spec: TSpec) => TStatus;
    reconcile: (context: ReconcileContext<TStatus>, resource: ManagedResource<TSpec, TStatus>) => MaybePromise<ReconcileResult<TStatus>>;
    timeoutMs?: number;
};
export type AnyResourceManagerDefinition = {
    name: string;
    initialStatus(spec: unknown): unknown;
    reconcile(context: ReconcileContext<unknown>, resource: ManagedResource): MaybePromise<ReconcileResult<unknown>>;
    timeoutMs?: number;
};
export type ResourceManagerQueueClaim = {
    resourceManager: string;
    key: string;
    ownerId: string;
    token: string;
    generation: number;
    queueVersion: number;
    resourceVersion: number;
    consecutiveErrors: number;
    expiresAt: string;
};
export type ResourceManagerEvent = {
    seq: number;
    recordedAt: string;
    resourceManager: string;
    key: string;
    type: string;
    payload: JsonObject;
};