case connect = "connect"

}

public enum SessionFileKind: String, Codable, Sendable {

case modified = "modified"

case read = "read"

}

public enum SessionFileRelevance: String, Codable, Sendable {

case modified = "modified"

case read = "read"

case mixed = "mixed"

}

public struct ConnectParams: Codable, Sendable {

public let minprotocol: Int

public let maxprotocol: Int

import fs from "node:fs/promises";

import path from "node:path";

import { describe, it } from "vitest";

import { ProtocolSchemas } from "./schema/protocol-schemas.js";

import { MIN_CLIENT_PROTOCOL_VERSION, PROTOCOL_VERSION } from "./version.js";

/**

);

}

});

it("emits named string-literal unions as Swift enums", async () => {

const swiftGeneratedPath =

"apps/shared/OpenClawKit/Sources/OpenClawProtocol/GatewayModels.swift";

const swiftGenerated = await readRepoFile(swiftGeneratedPath);

for (const [name, schema] of Object.entries(ProtocolSchemas)) {

const branches = schema.anyOf ?? schema.oneOf;

if (!branches || branches.length < 2) {

continue;

}

const values = branches.map((branch) => branch.const);

if (values.some((value) => typeof value !== "string")) {

continue;

}

const enumStart = `public enum ${name}: String, Codable, Sendable {`;

const start = swiftGenerated.indexOf(enumStart);

if (start < 0) {

throw new Error(`${swiftGeneratedPath}: missing Swift enum for ${name}.`);

}

const end = swiftGenerated.indexOf("\n}\n", start);

const enumSource = swiftGenerated.slice(start, end);

for (const value of values) {

assertPattern(

enumSource,

swiftGeneratedPath,

new RegExp(`= ${JSON.stringify(value)}$`, "m"),

`${name} must include the ${JSON.stringify(value)} literal.`,

);

}

}

});

});

].join("\n");

}

function stringLiteralUnionValues(schema: JsonSchema): string[] | undefined {

const branches = schema.oneOf ?? schema.anyOf;

if (!branches || branches.length < 2) {

return undefined;

}

const values = branches.map((branch) => literalSchemaValue(branch));

if (values.some((value) => typeof value !== "string")) {

return undefined;

}

const stringValues = values as string[];

return new Set(stringValues).size === stringValues.length ? stringValues : undefined;

}

function emitStruct(name: string, schema: JsonSchema): string {

const props = schema.properties ?? {};

const required = new Set(schema.required ?? []);

}

if (schema.type === "string" && schema.enum) {

parts.push(emitEnum(name, schema));

continue;

}

const literalUnionValues = stringLiteralUnionValues(schema);

if (literalUnionValues) {

parts.push(emitEnum(name, { enum: literalUnionValues }));

}

}