@rex0220/ksql-flownet 1.0.0

package/dist/requests/flownet-child-client.js

@@ -0,0 +1,243 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+export const DEFAULT_CHILD_OUTPUT_LIMIT = 64 * 1024;
+export const REQUESTED_BY_MAX_LENGTH = 1024;
+export class FlownetChildClient {
+    profile;
+    environment;
+    outputLimit;
+    cliPath;
+    executeProcess;
+    makeTempDirectory;
+    removeTempDirectory;
+    constructor(options) {
+        this.profile = options.profile;
+        this.environment = options.environment ?? process.env;
+        this.outputLimit = options.outputLimit ?? DEFAULT_CHILD_OUTPUT_LIMIT;
+        if (!Number.isSafeInteger(this.outputLimit) || this.outputLimit < 1) {
+            throw new RangeError("outputLimit must be a positive integer");
+        }
+        this.cliPath =
+            options.cliPath ??
+                fileURLToPath(new URL("../cli/index.js", import.meta.url));
+        this.executeProcess =
+            options.execute ??
+                ((command, args, childOptions) => executeChild(command, args, childOptions, this.outputLimit));
+        this.makeTempDirectory =
+            options.makeTempDirectory ??
+                (() => mkdtemp(join(tmpdir(), "ksql-flownet-request-")));
+        this.removeTempDirectory =
+            options.removeTempDirectory ??
+                ((path) => rm(path, { recursive: true, force: true }));
+    }
+    async status(network, selector) {
+        const result = await this.run([
+            "status",
+            network.networkId,
+            "--profile",
+            this.profile,
+            ...(typeof selector === "string"
+                ? ["--run-id", selector]
+                : ["--business-key", selector.businessKey]),
+            "--json",
+        ], undefined);
+        if (result.exitCode !== 0 || result.spawnError !== undefined) {
+            if (result.spawnError === undefined &&
+                /^Error \[RECORD_NOT_FOUND\]:/u.test(result.stderr)) {
+                return null;
+            }
+            throw new ChildClientError("STATUS_CHILD_FAILED", "status child failed", result);
+        }
+        try {
+            return JSON.parse(result.stdout);
+        }
+        catch (error) {
+            throw new ChildClientError("STATUS_JSON_INVALID", "status child returned invalid JSON", result, error);
+        }
+    }
+    async runNetwork(network, request) {
+        const args = [
+            "run-network",
+            network.definitionPath,
+            "--resume-run",
+            request.runId,
+            ...(request.rerunFromNode === null
+                ? []
+                : ["--rerun-from", request.rerunFromNode]),
+            "--json",
+        ];
+        const processResult = await this.run(args, requestedBy(request));
+        let output = null;
+        try {
+            output = JSON.parse(processResult.stdout);
+        }
+        catch {
+            // The classifier treats an absent machine-readable result as a rejection.
+        }
+        return { output, process: processResult };
+    }
+    async startNetwork(network, request, input) {
+        const args = [
+            "run-network",
+            network.definitionPath,
+            ...(input.businessKey === undefined
+                ? []
+                : ["--business-key", input.businessKey]),
+            ...(input.scheduledFor === undefined
+                ? []
+                : ["--scheduled-for", input.scheduledFor]),
+            "--json",
+        ];
+        const processResult = await this.run(args, requestedBy(request));
+        let output = null;
+        try {
+            output = JSON.parse(processResult.stdout);
+        }
+        catch {
+            // The classifier treats an absent machine-readable result as a rejection.
+        }
+        return { output, process: processResult };
+    }
+    async cancelRun(request, release) {
+        const directory = await this.makeTempDirectory();
+        const reasonPath = join(directory, "reason.txt");
+        try {
+            await writeFile(reasonPath, request.reason, {
+                encoding: "utf8",
+                mode: 0o600,
+            });
+            return await this.run([
+                "cancel-run",
+                "--run-id",
+                request.runId,
+                ...(release ? ["--release"] : []),
+                "--reason-file",
+                reasonPath,
+            ], requestedBy(request));
+        }
+        finally {
+            await this.removeTempDirectory(directory);
+        }
+    }
+    async archiveRun(network, request) {
+        const directory = await this.makeTempDirectory();
+        const reasonPath = join(directory, "reason.txt");
+        try {
+            await writeFile(reasonPath, request.reason, {
+                encoding: "utf8",
+                mode: 0o600,
+            });
+            const processResult = await this.run([
+                "archive-run",
+                network.definitionPath,
+                "--run-id",
+                request.runId,
+                "--reason-file",
+                reasonPath,
+            ], requestedBy(request));
+            let output = null;
+            try {
+                output = JSON.parse(processResult.stdout);
+            }
+            catch {
+                // The classifier treats an absent machine-readable result as invalid.
+            }
+            return { output, process: processResult };
+        }
+        finally {
+            await this.removeTempDirectory(directory);
+        }
+    }
+    run(args, correlation) {
+        const env = {
+            ...this.environment,
+            ...(correlation === undefined
+                ? {}
+                : { KSQL_FLOWNET_REQUESTED_BY: correlation }),
+        };
+        return this.executeProcess(process.execPath, [this.cliPath, ...args], {
+            env,
+            shell: false,
+        });
+    }
+}
+export class ChildClientError extends Error {
+    code;
+    result;
+    constructor(code, message, result, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.code = code;
+        this.result = result;
+        this.name = "ChildClientError";
+    }
+}
+export function requestedBy(request) {
+    let encoded;
+    try {
+        encoded = encodeURIComponent(request.creatorCode);
+    }
+    catch (error) {
+        throw new RequestCorrelationError("request creator cannot be percent-encoded", error);
+    }
+    const value = `app-request:${request.id}:${encoded}`;
+    if (value.length > REQUESTED_BY_MAX_LENGTH) {
+        throw new RequestCorrelationError("request correlation value is too long");
+    }
+    return value;
+}
+export class RequestCorrelationError extends Error {
+    code = "REQUESTED_BY_INVALID";
+    constructor(message, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = "RequestCorrelationError";
+    }
+}
+export function executeChild(command, args, options, limit) {
+    return new Promise((resolve) => {
+        let stdout = Buffer.alloc(0);
+        let stderr = Buffer.alloc(0);
+        let stdoutTruncated = false;
+        let stderrTruncated = false;
+        let spawnError;
+        const child = spawn(command, [...args], options);
+        child.stdout.on("data", (chunk) => {
+            const appended = appendBounded(stdout, chunk, limit);
+            stdout = appended.value;
+            stdoutTruncated ||= appended.truncated;
+        });
+        child.stderr.on("data", (chunk) => {
+            const appended = appendBounded(stderr, chunk, limit);
+            stderr = appended.value;
+            stderrTruncated ||= appended.truncated;
+        });
+        child.once("error", (error) => {
+            spawnError =
+                "code" in error && typeof error.code === "string"
+                    ? error.code
+                    : "SPAWN_FAILED";
+        });
+        child.once("close", (exitCode) => {
+            resolve({
+                exitCode,
+                stdout: stdout.toString("utf8"),
+                stderr: stderr.toString("utf8"),
+                stdoutTruncated,
+                stderrTruncated,
+                ...(spawnError === undefined ? {} : { spawnError }),
+            });
+        });
+    });
+}
+function appendBounded(current, chunk, limit) {
+    if (current.length >= limit)
+        return { value: current, truncated: true };
+    const remaining = limit - current.length;
+    return {
+        value: Buffer.concat([current, chunk.subarray(0, remaining)]),
+        truncated: chunk.length > remaining,
+    };
+}
+//# sourceMappingURL=flownet-child-client.js.map

package/dist/requests/kintone-request-store.d.ts

@@ -0,0 +1,44 @@
+import { type KintoneClientConfig } from "../persistence/kintone/client.js";
+import { type RequestRecord, type TerminalRequestState, type RequestEnvelope } from "./request-model.js";
+export declare const DEFAULT_REQUEST_FETCH_LIMIT = 100;
+export declare const MAX_REQUEST_FETCH_LIMIT = 500;
+export interface KintoneRequestStoreConfig extends KintoneClientConfig {
+    readonly fetchLimit?: number;
+}
+export interface RequestResult {
+    readonly state: TerminalRequestState;
+    readonly code: string;
+    readonly message: string;
+}
+export interface InvalidRequestRecord {
+    readonly id: string;
+    readonly revision: number;
+    readonly requestState: RequestEnvelope["requestState"];
+    readonly cancelRequested: RequestEnvelope["cancelRequested"];
+    readonly issues: readonly {
+        readonly code: string;
+        readonly field: string;
+        readonly message: string;
+    }[];
+}
+export interface RequestedRecords {
+    readonly valid: readonly RequestRecord[];
+    readonly invalid: readonly InvalidRequestRecord[];
+    readonly skipped: number;
+}
+export declare class KintoneRequestStore {
+    private readonly client;
+    private readonly fetchLimit;
+    constructor(config: KintoneRequestStoreConfig);
+    listRequested(): Promise<RequestedRecords>;
+    cancelBeforeClaim(request: RequestEnvelope, result: RequestResult): Promise<boolean>;
+    listAccepted(): Promise<readonly RequestRecord[]>;
+    rejectInvalid(request: Pick<InvalidRequestRecord, "id" | "revision">, result: RequestResult): Promise<void>;
+    claim(request: RequestRecord, claimedHost: string, now: string): Promise<RequestRecord | null>;
+    heartbeat(request: RequestRecord, now: string): Promise<RequestRecord>;
+    writeResult(request: RequestRecord, result: RequestResult): Promise<RequestRecord>;
+    getById(id: string): Promise<RequestRecord | null>;
+    private resultRecord;
+    private readIdentity;
+}
+//# sourceMappingURL=kintone-request-store.d.ts.map

package/dist/requests/kintone-request-store.js

@@ -0,0 +1,202 @@
+import { KintoneApiError, KintoneClient, } from "../persistence/kintone/client.js";
+import { parseRequestRecord, parseRequestEnvelope, RequestValidationError, validateRequestRecord, } from "./request-model.js";
+export const DEFAULT_REQUEST_FETCH_LIMIT = 100;
+export const MAX_REQUEST_FETCH_LIMIT = 500;
+function field(value) {
+    return { value };
+}
+function conflict(error) {
+    return (error instanceof KintoneApiError &&
+        (error.status === 409 ||
+            error.apiCode === "GAIA_CO02" ||
+            error.apiCode === "GAIA_DA02"));
+}
+function terminalMatches(record, result) {
+    return (record.requestState === result.state &&
+        record.resultCode === result.code &&
+        record.resultMessage === result.message);
+}
+function withRevision(record, revision) {
+    return { ...record, revision };
+}
+function assertValid(record) {
+    const issues = validateRequestRecord(record);
+    if (issues.length > 0)
+        throw new RequestValidationError(issues);
+}
+export class KintoneRequestStore {
+    client;
+    fetchLimit;
+    constructor(config) {
+        const fetchLimit = config.fetchLimit ?? DEFAULT_REQUEST_FETCH_LIMIT;
+        if (!Number.isSafeInteger(fetchLimit) ||
+            fetchLimit < 1 ||
+            fetchLimit > MAX_REQUEST_FETCH_LIMIT) {
+            throw new RangeError(`fetchLimit must be an integer from 1 to ${MAX_REQUEST_FETCH_LIMIT}`);
+        }
+        this.fetchLimit = fetchLimit;
+        this.client = new KintoneClient(config);
+    }
+    async listRequested() {
+        const records = await this.client.getRecords(`request_state in ("REQUESTED") order by 作成日時 asc, $id asc limit ${this.fetchLimit}`);
+        const valid = [];
+        const invalid = [];
+        let skipped = 0;
+        for (const record of records) {
+            let envelope;
+            try {
+                envelope = parseRequestEnvelope(record);
+            }
+            catch {
+                skipped += 1;
+                continue;
+            }
+            try {
+                valid.push(parseRequestRecord(record));
+            }
+            catch (error) {
+                if (!(error instanceof RequestValidationError))
+                    throw error;
+                invalid.push({
+                    id: envelope.id,
+                    revision: envelope.revision,
+                    requestState: envelope.requestState,
+                    cancelRequested: envelope.cancelRequested,
+                    issues: error.issues,
+                });
+            }
+        }
+        return { valid, invalid, skipped };
+    }
+    async cancelBeforeClaim(request, result) {
+        if (request.requestState !== "REQUESTED" ||
+            request.cancelRequested !== true ||
+            result.state !== "CANCELLED")
+            throw new Error("cancellation requires REQUESTED -> CANCELLED");
+        try {
+            await this.client.putRecordById(request.id, request.revision, {
+                request_state: field("CANCELLED"),
+                result_code: field(result.code),
+                result_message: field(result.message),
+            });
+            return true;
+        }
+        catch (error) {
+            if (conflict(error))
+                return false;
+            throw error;
+        }
+    }
+    async listAccepted() {
+        const records = await this.client.getRecords(`request_state in ("ACCEPTED") order by claim_heartbeat_at asc, $id asc limit ${this.fetchLimit}`);
+        return records.map(parseRequestRecord);
+    }
+    async rejectInvalid(request, result) {
+        if (result.state !== "REJECTED") {
+            throw new Error("invalid requests can only be REJECTED");
+        }
+        try {
+            await this.client.putRecordById(request.id, request.revision, {
+                request_state: field("REJECTED"),
+                result_code: field(result.code),
+                result_message: field(result.message),
+            });
+        }
+        catch (error) {
+            if (!conflict(error))
+                throw error;
+        }
+    }
+    async claim(request, claimedHost, now) {
+        if (request.requestState !== "REQUESTED") {
+            throw new Error("only REQUESTED records can be claimed");
+        }
+        const claimed = {
+            ...request,
+            requestState: "ACCEPTED",
+            claimedAt: now,
+            claimedHost,
+            claimHeartbeatAt: now,
+        };
+        assertValid(claimed);
+        try {
+            const revision = await this.client.putRecordById(request.id, request.revision, {
+                request_state: field("ACCEPTED"),
+                claimed_at: field(now),
+                claimed_host: field(claimedHost),
+                claim_heartbeat_at: field(now),
+            });
+            return withRevision(claimed, revision);
+        }
+        catch (error) {
+            if (conflict(error))
+                return null;
+            throw error;
+        }
+    }
+    async heartbeat(request, now) {
+        if (request.requestState !== "ACCEPTED") {
+            throw new Error("only ACCEPTED records can receive a heartbeat");
+        }
+        const updated = { ...request, claimHeartbeatAt: now };
+        assertValid(updated);
+        const revision = await this.client.putRecordById(request.id, request.revision, { claim_heartbeat_at: field(now) });
+        return withRevision(updated, revision);
+    }
+    async writeResult(request, result) {
+        if (request.requestState !== "ACCEPTED" &&
+            !(request.requestState === "REQUESTED" && result.state === "REJECTED")) {
+            throw new Error("results require ACCEPTED, except direct validation rejection from REQUESTED");
+        }
+        const projected = this.resultRecord(request, result, request.revision);
+        assertValid(projected);
+        const update = {
+            request_state: field(result.state),
+            result_code: field(result.code),
+            result_message: field(result.message),
+        };
+        try {
+            const revision = await this.client.putRecordById(request.id, request.revision, update);
+            return this.resultRecord(request, result, revision);
+        }
+        catch (error) {
+            if (!conflict(error))
+                throw error;
+        }
+        const current = await this.getById(request.id);
+        if (current === null)
+            throw new Error("request record disappeared after conflict");
+        if (terminalMatches(current, result))
+            return current;
+        const revision = await this.client.putRecordById(current.id, current.revision, update);
+        return this.resultRecord(current, result, revision);
+    }
+    async getById(id) {
+        const records = await this.client.getRecords(`$id in ("${id}") limit 1`);
+        const record = records[0];
+        return record === undefined ? null : parseRequestRecord(record);
+    }
+    resultRecord(request, result, revision) {
+        return withRevision({
+            ...request,
+            requestState: result.state,
+            resultCode: result.code,
+            resultMessage: result.message,
+        }, revision);
+    }
+    readIdentity(record) {
+        const id = record.$id?.value;
+        const revision = record.$revision?.value;
+        if (typeof id !== "string" ||
+            !/^\d+$/.test(id) ||
+            typeof revision !== "string" ||
+            !/^\d+$/.test(revision)) {
+            return null;
+        }
+        const parsedRevision = Number(revision);
+        if (!Number.isSafeInteger(parsedRevision) || parsedRevision < 1)
+            return null;
+        return { id, revision: parsedRevision };
+    }
+}
+//# sourceMappingURL=kintone-request-store.js.map

package/dist/requests/poll-requests-config.d.ts

@@ -0,0 +1,26 @@
+export declare const DEFAULT_REQUEST_HEARTBEAT_INTERVAL_MS = 60000;
+export declare const DEFAULT_REQUEST_STALE_AFTER_MS: number;
+export declare const KINTONE_DATETIME_PRECISION_ALLOWANCE_MS = 60000;
+export interface PollRequestsNetwork {
+    readonly networkId: string;
+    readonly definitionPath: string;
+    readonly appStart: boolean;
+}
+export interface PollRequestsConfig {
+    readonly networks: readonly PollRequestsNetwork[];
+    readonly heartbeatIntervalMs: number;
+    readonly staleAfterMs: number;
+    readonly stalePrecisionAllowanceMs: number;
+}
+export interface LoadPollRequestsConfigOptions {
+    readonly heartbeatIntervalMs?: number;
+    readonly staleAfterMs?: number;
+}
+export declare class PollRequestsConfigError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string, cause?: unknown);
+}
+export declare function loadPollRequestsConfig(allowlistPath: string, options?: LoadPollRequestsConfigOptions): PollRequestsConfig;
+export declare function definitionPathForNetwork(config: PollRequestsConfig, networkId: string): string;
+export declare function networkForNetworkId(config: PollRequestsConfig, networkId: string): PollRequestsNetwork;
+//# sourceMappingURL=poll-requests-config.d.ts.map

package/dist/requests/poll-requests-config.js

@@ -0,0 +1,105 @@
+import { isAbsolute, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { parseDocument } from "yaml";
+import { validateNetworkPath } from "../domain/validate-network-path.js";
+export const DEFAULT_REQUEST_HEARTBEAT_INTERVAL_MS = 60_000;
+export const DEFAULT_REQUEST_STALE_AFTER_MS = 15 * 60_000;
+export const KINTONE_DATETIME_PRECISION_ALLOWANCE_MS = 60_000;
+export class PollRequestsConfigError extends Error {
+    code;
+    constructor(code, message, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = "PollRequestsConfigError";
+        this.code = code;
+    }
+}
+function positiveInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new PollRequestsConfigError("THRESHOLD_INVALID", `${name} must be a positive integer`);
+    }
+    return value;
+}
+function objectValue(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new PollRequestsConfigError("CONFIG_SHAPE_INVALID", "allowlist root must be an object");
+    }
+    return value;
+}
+export function loadPollRequestsConfig(allowlistPath, options = {}) {
+    if (!isAbsolute(allowlistPath)) {
+        throw new PollRequestsConfigError("ALLOWLIST_PATH_NOT_ABSOLUTE", "allowlist path must be absolute");
+    }
+    let source;
+    try {
+        source = readFileSync(allowlistPath, "utf8");
+    }
+    catch (error) {
+        throw new PollRequestsConfigError("ALLOWLIST_UNREADABLE", "allowlist file cannot be read", error);
+    }
+    const document = parseDocument(source, { uniqueKeys: true });
+    if (document.errors.length > 0) {
+        throw new PollRequestsConfigError("ALLOWLIST_PARSE_ERROR", `invalid allowlist: ${document.errors[0]?.message ?? "parse error"}`);
+    }
+    const root = objectValue(document.toJS());
+    if (!Array.isArray(root.networks) ||
+        root.networks.length === 0 ||
+        Object.keys(root).some((key) => key !== "networks")) {
+        throw new PollRequestsConfigError("CONFIG_SHAPE_INVALID", "allowlist must contain only a non-empty networks array");
+    }
+    const seen = new Set();
+    const networks = root.networks.map((entry, index) => {
+        const item = objectValue(entry);
+        if (Object.keys(item).some((key) => key !== "network_id" &&
+            key !== "definition_path" &&
+            key !== "app_start") ||
+            typeof item.network_id !== "string" ||
+            item.network_id.trim() === "" ||
+            typeof item.definition_path !== "string" ||
+            item.definition_path.trim() === "" ||
+            (item.app_start !== undefined && typeof item.app_start !== "boolean")) {
+            throw new PollRequestsConfigError("NETWORK_ENTRY_INVALID", `networks[${index}] must contain network_id and definition_path`);
+        }
+        if (seen.has(item.network_id)) {
+            throw new PollRequestsConfigError("DUPLICATE_NETWORK", `duplicate network_id: ${item.network_id}`);
+        }
+        seen.add(item.network_id);
+        if (!isAbsolute(item.definition_path)) {
+            throw new PollRequestsConfigError("DEFINITION_PATH_NOT_ABSOLUTE", `definition path for ${item.network_id} must be absolute`);
+        }
+        const definitionPath = resolve(item.definition_path);
+        const loaded = validateNetworkPath(definitionPath);
+        if (loaded.definition === undefined || loaded.errors.length > 0) {
+            throw new PollRequestsConfigError("NETWORK_DEFINITION_INVALID", `network definition for ${item.network_id} is unavailable or invalid`);
+        }
+        if (loaded.definition.network_id !== item.network_id) {
+            throw new PollRequestsConfigError("NETWORK_ID_MISMATCH", `allowlist network_id does not match definition: ${item.network_id}`);
+        }
+        return {
+            networkId: item.network_id,
+            definitionPath,
+            appStart: item.app_start === true,
+        };
+    });
+    const heartbeatIntervalMs = positiveInteger(options.heartbeatIntervalMs ?? DEFAULT_REQUEST_HEARTBEAT_INTERVAL_MS, "heartbeatIntervalMs");
+    const staleAfterMs = positiveInteger(options.staleAfterMs ?? DEFAULT_REQUEST_STALE_AFTER_MS, "staleAfterMs");
+    if (staleAfterMs <= heartbeatIntervalMs) {
+        throw new PollRequestsConfigError("THRESHOLD_INVALID", "staleAfterMs must be greater than heartbeatIntervalMs");
+    }
+    return {
+        networks,
+        heartbeatIntervalMs,
+        staleAfterMs,
+        stalePrecisionAllowanceMs: KINTONE_DATETIME_PRECISION_ALLOWANCE_MS,
+    };
+}
+export function definitionPathForNetwork(config, networkId) {
+    return networkForNetworkId(config, networkId).definitionPath;
+}
+export function networkForNetworkId(config, networkId) {
+    const match = config.networks.find((network) => network.networkId === networkId);
+    if (match === undefined) {
+        throw new PollRequestsConfigError("NETWORK_NOT_ALLOWED", `network is not in the allowlist: ${networkId}`);
+    }
+    return match;
+}
+//# sourceMappingURL=poll-requests-config.js.map

package/dist/requests/request-model.d.ts

@@ -0,0 +1,57 @@
+import type { KintoneRecord } from "../persistence/kintone/client.js";
+export declare const REQUEST_TYPES: readonly ["RERUN", "STOP", "RELEASE", "START", "CLOSE"];
+export type RequestType = (typeof REQUEST_TYPES)[number];
+export declare const REQUEST_STATES: readonly ["REQUESTED", "ACCEPTED", "DONE", "REJECTED", "CANCELLED"];
+export type RequestState = (typeof REQUEST_STATES)[number];
+export type TerminalRequestState = Extract<RequestState, "DONE" | "REJECTED" | "CANCELLED">;
+export type CancelRequestedEnvelope = boolean | "INVALID";
+export interface RequestEnvelope {
+    readonly id: string;
+    readonly revision: number;
+    readonly requestState: RequestState;
+    readonly cancelRequested: CancelRequestedEnvelope;
+}
+export declare const REQUEST_VALUE_LIMITS: {
+    readonly runId: 128;
+    readonly networkId: 128;
+    readonly businessKey: 128;
+    readonly rerunFromNode: 128;
+    readonly reason: 65535;
+    readonly creatorCode: 256;
+    readonly claimedHost: 256;
+    readonly resultCode: 128;
+    readonly resultMessage: 65535;
+};
+export interface RequestRecord {
+    readonly id: string;
+    readonly revision: number;
+    readonly creatorCode: string;
+    readonly createdAt: string;
+    readonly requestType: RequestType;
+    readonly runId: string;
+    readonly networkId: string | null;
+    readonly businessKey: string | null;
+    readonly scheduledFor: string | null;
+    readonly rerunFromNode: string | null;
+    readonly reason: string;
+    readonly requestState: RequestState;
+    readonly cancelRequested: boolean;
+    readonly claimedAt: string | null;
+    readonly claimedHost: string | null;
+    readonly claimHeartbeatAt: string | null;
+    readonly resultCode: string | null;
+    readonly resultMessage: string | null;
+}
+export interface RequestValidationIssue {
+    readonly code: string;
+    readonly field: string;
+    readonly message: string;
+}
+export declare class RequestValidationError extends Error {
+    readonly issues: readonly RequestValidationIssue[];
+    constructor(issues: readonly RequestValidationIssue[]);
+}
+export declare function validateRequestRecord(record: RequestRecord): readonly RequestValidationIssue[];
+export declare function parseRequestEnvelope(record: KintoneRecord): RequestEnvelope;
+export declare function parseRequestRecord(record: KintoneRecord): RequestRecord;
+//# sourceMappingURL=request-model.d.ts.map