@pump-inc/cli 0.0.1

package/dist/api-client-bnV0ib_r.cjs

@@ -0,0 +1,1207 @@
+
+//#region ../node_modules/.pnpm/typescript-result@3.5.2/node_modules/typescript-result/dist/index.js
+function isPromise(value) {
+	if (value === null || value === void 0) return false;
+	if (typeof value !== "object") return false;
+	return value instanceof Promise || "then" in value;
+}
+function isFunction(value) {
+	return typeof value === "function";
+}
+function isAsyncFn(fn) {
+	return fn.constructor.name === "AsyncFunction";
+}
+function isGenerator(obj) {
+	return typeof obj === "object" && obj !== null && typeof obj.next === "function" && typeof obj.throw === "function" && typeof obj.return === "function" && typeof obj[Symbol.iterator] === "function" && obj[Symbol.iterator]() === obj;
+}
+function isAsyncGenerator(obj) {
+	return typeof obj === "object" && obj !== null && typeof obj.next === "function" && typeof obj.throw === "function" && typeof obj.return === "function" && typeof obj[Symbol.asyncIterator] === "function" && obj[Symbol.asyncIterator]() === obj;
+}
+var NonExhaustiveError = class extends Error {
+	constructor(error) {
+		super("Not all error cases were handled");
+		this.error = error;
+	}
+};
+var Matcher = class {
+	constructor(error) {
+		this.error = error;
+	}
+	cases = [];
+	defaultHandler = void 0;
+	when(value, ...args) {
+		const cases = [value, ...args.slice(0, -1)];
+		const handler = args.at(-1);
+		this.cases.push(...cases.map((value2) => ({
+			value: value2,
+			handler
+		})));
+		return this;
+	}
+	else = (handler) => {
+		if (this.defaultHandler) throw new Error("already registered an 'else' handler");
+		this.defaultHandler = handler;
+		return this;
+	};
+	run = () => {
+		const isAsync = this.cases.some((item) => isAsyncFn(item.handler));
+		for (const item of this.cases) if (isFunction(item.value) && this.error instanceof item.value || item.value === this.error) {
+			const value = item.handler(this.error);
+			return isPromise(value) ? value : isAsync ? Promise.resolve(value) : value;
+		}
+		if (this.defaultHandler) return this.defaultHandler(this.error);
+		throw new NonExhaustiveError(this.error);
+	};
+};
+var AsyncResult = class _AsyncResult extends Promise {
+	constructor(executor) {
+		super(executor);
+	}
+	*[Symbol.iterator]() {
+		return yield this;
+	}
+	get isAsyncResult() {
+		return true;
+	}
+	async toTuple() {
+		return (await this).toTuple();
+	}
+	async errorOrNull() {
+		return (await this).errorOrNull();
+	}
+	async getOrNull() {
+		return (await this).getOrNull();
+	}
+	async getOrDefault(defaultValue) {
+		return (await this).getOrDefault(defaultValue);
+	}
+	async getOrElse(onFailure) {
+		return (await this).getOrElse(onFailure);
+	}
+	async getOrThrow() {
+		return (await this).getOrThrow();
+	}
+	async fold(onSuccess, onFailure) {
+		return (await this).fold(onSuccess, onFailure);
+	}
+	onFailure(action) {
+		return new _AsyncResult((resolve, reject) => this.then(async (result) => {
+			try {
+				if (!result.ok) await action(result.error);
+				resolve(result);
+			} catch (e) {
+				reject(e);
+			}
+		}).catch(reject));
+	}
+	onSuccess(action) {
+		return new _AsyncResult((resolve, reject) => this.then(async (result) => {
+			try {
+				if (result.ok) await action(result.value);
+				resolve(result);
+			} catch (error) {
+				reject(error);
+			}
+		}).catch(reject));
+	}
+	map(transform) {
+		return new _AsyncResult((resolve, reject) => {
+			this.then(async (result) => resolve(await result.map(transform))).catch(reject);
+		});
+	}
+	mapCatching(transformValue, transformError) {
+		return new _AsyncResult((resolve, reject) => {
+			this.map(transformValue).then((result) => resolve(result)).catch((error) => {
+				try {
+					resolve(ResultFactory.error(transformError ? transformError(error) : error));
+				} catch (err) {
+					reject(err);
+				}
+			});
+		});
+	}
+	mapError(transform) {
+		return new _AsyncResult((resolve, reject) => this.then(async (result) => {
+			try {
+				resolve(result.mapError(transform));
+			} catch (error) {
+				reject(error);
+			}
+		}).catch(reject));
+	}
+	recover(onFailure) {
+		return new _AsyncResult((resolve, reject) => this.then(async (result) => {
+			try {
+				resolve(await result.recover(onFailure));
+			} catch (error) {
+				reject(error);
+			}
+		}).catch(reject));
+	}
+	recoverCatching(onFailure, transformError) {
+		return new _AsyncResult((resolve, reject) => this.then((result) => {
+			resolve(result.recoverCatching(onFailure, transformError));
+		}).catch(reject));
+	}
+	toString() {
+		return "AsyncResult";
+	}
+	static error(error) {
+		return new _AsyncResult((resolve) => resolve(ResultFactory.error(error)));
+	}
+	static ok(value) {
+		return new _AsyncResult((resolve) => resolve(ResultFactory.ok(value)));
+	}
+	static fromPromise(promise) {
+		return new _AsyncResult((resolve, reject) => {
+			promise.then((value) => resolve(ResultFactory.isResult(value) ? value : ResultFactory.ok(value))).catch(reject);
+		});
+	}
+	static fromPromiseCatching(promise, transform) {
+		return new _AsyncResult((resolve, reject) => {
+			promise.then((value) => resolve(ResultFactory.isResult(value) ? value : ResultFactory.ok(value))).catch((caughtError) => {
+				resolve(ResultFactory.error(transform?.(caughtError) ?? caughtError));
+			}).catch(reject);
+		});
+	}
+};
+var Result = class {
+	constructor(_value, _error) {
+		this._value = _value;
+		this._error = _error;
+	}
+	*[Symbol.iterator]() {
+		return yield this;
+	}
+	get isResult() {
+		return true;
+	}
+	get value() {
+		return this._value;
+	}
+	get error() {
+		return this._error;
+	}
+	get success() {
+		return this.error === void 0;
+	}
+	get failure() {
+		return this.error !== void 0;
+	}
+	get ok() {
+		return this.success;
+	}
+	isOk() {
+		return this.success;
+	}
+	isError() {
+		return this.failure;
+	}
+	toTuple() {
+		return [this._value ?? null, this._error ?? null];
+	}
+	errorOrNull() {
+		return this.failure ? this._error : null;
+	}
+	getOrNull() {
+		return this.success ? this._value : null;
+	}
+	getOrDefault(defaultValue) {
+		return this.success ? this._value : defaultValue;
+	}
+	getOrElse(onFailure) {
+		if (isAsyncFn(onFailure)) return this.success ? Promise.resolve(this._value) : onFailure(this._error);
+		return this.success ? this._value : onFailure(this._error);
+	}
+	getOrThrow() {
+		if (this.success) return this._value;
+		throw this._error;
+	}
+	fold(onSuccess, onFailure) {
+		const isAsync = isAsyncFn(onSuccess) || isAsyncFn(onFailure);
+		const outcome = this.success ? onSuccess(this._value) : onFailure(this._error);
+		return isAsync && !isPromise(outcome) ? Promise.resolve(outcome) : outcome;
+	}
+	match() {
+		return this.failure ? new Matcher(this._error) : void 0;
+	}
+	onFailure(action) {
+		const isAsync = isAsyncFn(action);
+		if (this.failure) {
+			const outcome = action(this._error);
+			if (isAsync) return new AsyncResult((resolve) => {
+				outcome.then(() => resolve(ResultFactory.error(this._error)));
+			});
+			return this;
+		}
+		return isAsync ? AsyncResult.ok(this._value) : this;
+	}
+	onSuccess(action) {
+		const isAsync = isAsyncFn(action);
+		if (this.success) {
+			const outcome = action(this._value);
+			if (isAsync) return new AsyncResult((resolve) => {
+				outcome.then(() => resolve(ResultFactory.ok(this._value)));
+			});
+			return this;
+		}
+		return isAsync ? AsyncResult.error(this._error) : this;
+	}
+	map(transform) {
+		return this.success ? ResultFactory.run(() => transform(this._value)) : isAsyncFn(transform) ? AsyncResult.error(this._error) : this;
+	}
+	mapCatching(transformValue, transformError) {
+		return this.success ? ResultFactory.try(() => transformValue(this._value), transformError) : this;
+	}
+	mapError(transform) {
+		if (this.success) return this;
+		return ResultFactory.error(transform(this._error));
+	}
+	recover(onFailure) {
+		return this.success ? isAsyncFn(onFailure) ? AsyncResult.ok(this._value) : this : ResultFactory.run(() => onFailure(this._error));
+	}
+	recoverCatching(onFailure, transformError) {
+		return this.success ? isAsyncFn(onFailure) ? AsyncResult.ok(this._value) : this : ResultFactory.try(() => onFailure(this._error), transformError);
+	}
+	toString() {
+		if (this.success) return `Result.ok(${this._value})`;
+		return `Result.error(${this.error})`;
+	}
+};
+var ResultFactory = class _ResultFactory {
+	constructor() {}
+	static ok(value) {
+		return new Result(value, void 0);
+	}
+	static error(error) {
+		return new Result(void 0, error);
+	}
+	static isResult(possibleResult) {
+		return possibleResult instanceof Result;
+	}
+	static isAsyncResult(possibleAsyncResult) {
+		return possibleAsyncResult instanceof AsyncResult;
+	}
+	static run(fn) {
+		const returnValue = fn();
+		if (isGenerator(returnValue) || isAsyncGenerator(returnValue)) return _ResultFactory.handleGenerator(returnValue);
+		if (isPromise(returnValue)) return AsyncResult.fromPromise(returnValue);
+		return _ResultFactory.isResult(returnValue) ? returnValue : _ResultFactory.ok(returnValue);
+	}
+	static allInternal(items, opts) {
+		const runner = opts.catching ? _ResultFactory.try : _ResultFactory.run;
+		const flattened = [];
+		let isAsync = items.some(isPromise);
+		let hasFailure = false;
+		for (const item of items) if (isFunction(item)) {
+			if (hasFailure) continue;
+			const returnValue = runner(item);
+			if (_ResultFactory.isResult(returnValue) && !returnValue.ok) {
+				hasFailure = true;
+				if (!isAsync) return returnValue;
+			}
+			if (_ResultFactory.isAsyncResult(returnValue)) isAsync = true;
+			flattened.push(returnValue);
+		} else if (_ResultFactory.isResult(item)) {
+			if (!item.ok) {
+				hasFailure = true;
+				if (!isAsync) return item;
+			}
+			flattened.push(item);
+		} else if (_ResultFactory.isAsyncResult(item)) {
+			isAsync = true;
+			flattened.push(item);
+		} else if (isPromise(item)) {
+			isAsync = true;
+			flattened.push(opts.catching ? AsyncResult.fromPromiseCatching(item) : AsyncResult.fromPromise(item));
+		} else flattened.push(_ResultFactory.ok(item));
+		if (isAsync) return new AsyncResult((resolve, reject) => {
+			const asyncResults = [];
+			const asyncIndexes = [];
+			for (let i = 0; i < flattened.length; i++) {
+				const item = flattened[i];
+				if (_ResultFactory.isAsyncResult(item)) {
+					asyncResults.push(item);
+					asyncIndexes.push(i);
+				}
+			}
+			Promise.all(asyncResults).then((resolvedResults) => {
+				const merged = [...flattened];
+				for (let i = 0; i < resolvedResults.length; i++) merged[asyncIndexes[i]] = resolvedResults[i];
+				const firstFailedResult = merged.find((resolvedResult) => !resolvedResult.ok);
+				if (firstFailedResult) {
+					resolve(firstFailedResult);
+					return;
+				}
+				resolve(_ResultFactory.ok(merged.map((result) => result.getOrNull())));
+			}).catch((reason) => {
+				reject(reason);
+			});
+		});
+		return _ResultFactory.ok(flattened.map((result) => result.getOrNull()));
+	}
+	static all(...items) {
+		return _ResultFactory.allInternal(items, { catching: false });
+	}
+	static allCatching(...items) {
+		return _ResultFactory.allInternal(items, { catching: true });
+	}
+	static wrap(fn, transformError) {
+		return function wrapped(...args) {
+			return _ResultFactory.try(() => fn(...args), transformError);
+		};
+	}
+	static try(fn, transform) {
+		try {
+			const returnValue = fn();
+			if (isGenerator(returnValue)) return _ResultFactory.handleGenerator(returnValue);
+			if (isAsyncGenerator(returnValue)) {
+				const asyncResult = _ResultFactory.handleGenerator(returnValue);
+				return AsyncResult.fromPromiseCatching(asyncResult, transform);
+			}
+			if (isPromise(returnValue)) return AsyncResult.fromPromiseCatching(returnValue, transform);
+			return _ResultFactory.isResult(returnValue) ? returnValue : _ResultFactory.ok(returnValue);
+		} catch (caughtError) {
+			return _ResultFactory.error(transform?.(caughtError) ?? caughtError);
+		}
+	}
+	static fromAsync(valueOrFn) {
+		return _ResultFactory.run(typeof valueOrFn === "function" ? valueOrFn : () => valueOrFn);
+	}
+	static fromAsyncCatching(valueOrFn, transformError) {
+		return _ResultFactory.try(typeof valueOrFn === "function" ? valueOrFn : () => valueOrFn, transformError);
+	}
+	static handleGenerator(it) {
+		function handleResult(result2) {
+			if (!result2.ok) return iterate(it.return(result2));
+			return iterate(it.next(result2.value));
+		}
+		function handleStep(step) {
+			if (step.done) {
+				if (step.value instanceof Result || step.value instanceof AsyncResult) return step.value;
+				return _ResultFactory.ok(step.value);
+			}
+			if (step.value instanceof Result) return handleResult(step.value);
+			if (step.value instanceof AsyncResult) return step.value.then(handleResult);
+			return iterate(it.next(step.value));
+		}
+		function iterate(iteratorResult) {
+			return isPromise(iteratorResult) ? iteratorResult.then(handleStep) : handleStep(iteratorResult);
+		}
+		const result = iterate(it.next());
+		return isPromise(result) ? AsyncResult.fromPromise(result) : result;
+	}
+	static gen(generatorOrSelfOrFn, fn) {
+		const it = isGenerator(generatorOrSelfOrFn) || isAsyncGenerator(generatorOrSelfOrFn) ? generatorOrSelfOrFn : typeof generatorOrSelfOrFn === "function" ? generatorOrSelfOrFn() : fn?.apply(generatorOrSelfOrFn);
+		return _ResultFactory.handleGenerator(it);
+	}
+	static genCatching(generatorOrSelfOrFn, transformValueOrError, transformError) {
+		const isGen = isGenerator(generatorOrSelfOrFn) || isAsyncGenerator(generatorOrSelfOrFn);
+		const self = typeof generatorOrSelfOrFn === "function" || isGen ? void 0 : generatorOrSelfOrFn;
+		const tValue = typeof generatorOrSelfOrFn === "function" ? generatorOrSelfOrFn : transformValueOrError;
+		const tError = typeof generatorOrSelfOrFn === "function" || isGen ? transformValueOrError : transformError;
+		try {
+			const it = isGen ? generatorOrSelfOrFn : self ? tValue.apply(generatorOrSelfOrFn) : tValue();
+			const result = _ResultFactory.handleGenerator(it);
+			if (_ResultFactory.isAsyncResult(result)) return result.catch((error) => AsyncResult.error(tError?.(error) ?? error));
+			return result;
+		} catch (error) {
+			return _ResultFactory.error(tError?.(error) ?? error);
+		}
+	}
+	static assertOk(result) {
+		if (!result.ok) throw new Error("Expected a successful result, but got an error instead");
+	}
+	static assertError(result) {
+		if (result.ok) throw new Error("Expected a failed result, but got a value instead");
+	}
+	static [Symbol.hasInstance](instance) {
+		return instance instanceof Result;
+	}
+};
+var Result2 = ResultFactory;
+
+//#endregion
+//#region ../api/dist/api-client.js
+var InvalidYamlError = class extends Error {
+	type = "invalid-yaml-error";
+	issues = [];
+	constructor(message, issues) {
+		super(message);
+		this.issues = issues || [];
+	}
+};
+var ApiError = class extends Error {
+	type = "api-error";
+	response;
+	constructor(message, response) {
+		super(message);
+		this.response = response;
+	}
+};
+var BaseClient = class {
+	baseUrl;
+	apiKey;
+	constructor(baseUrl, apiKey) {
+		this.baseUrl = baseUrl;
+		this.apiKey = apiKey;
+	}
+	/**
+	* Generic method to make HTTP requests with common headers and error handling
+	*/
+	async makeRequest(endpoint, options = {}) {
+		const { method = "GET", headers = {}, body, throwOnError = true } = options;
+		const fetchOptions = {
+			method,
+			headers: {
+				"Content-Type": "application/json",
+				...headers,
+				"Authorization": `Bearer ${this.apiKey}`
+			},
+			credentials: "include"
+		};
+		if (body !== void 0) if (typeof body === "string") fetchOptions.body = body;
+		else if (headers["Content-Type"]?.includes("yaml")) fetchOptions.body = body;
+		else fetchOptions.body = JSON.stringify(body);
+		const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl : `${this.baseUrl}/`;
+		const requestUrl = new URL(endpoint, baseUrl);
+		const response = await fetch(requestUrl.toString(), fetchOptions);
+		const data = await response.json();
+		if (!response.ok && throwOnError) {
+			const errorData = data;
+			throw new ApiError(errorData.error ?? "Request failed", errorData);
+		}
+		return data;
+	}
+	/**
+	* HTTP method helpers
+	*/
+	async get(endpoint, options) {
+		return this.makeRequest(endpoint, {
+			...options,
+			method: "GET"
+		});
+	}
+	async post(endpoint, body, options) {
+		return this.makeRequest(endpoint, {
+			...options,
+			method: "POST",
+			body
+		});
+	}
+	async patch(endpoint, body, options) {
+		return this.makeRequest(endpoint, {
+			...options,
+			method: "PATCH",
+			body
+		});
+	}
+	async delete(endpoint, options) {
+		return this.makeRequest(endpoint, {
+			...options,
+			method: "DELETE"
+		});
+	}
+	async put(endpoint, body, options) {
+		return this.makeRequest(endpoint, {
+			...options,
+			method: "PUT",
+			body
+		});
+	}
+	/**
+	* Generic Result helper for consistent error handling
+	*/
+	async withResult(operation) {
+		try {
+			const result = await operation();
+			return Result2.ok(result);
+		} catch (error) {
+			if (error instanceof ApiError) return Result2.error(error);
+			console.error("Unexpected error:", error);
+			return Result2.error(new ApiError("Internal server error", { error: "Internal server error" }));
+		}
+	}
+	/**
+	* Generic method to make HTTP requests without authentication
+	*/
+	async makeUnauthenticatedRequest(endpoint, options = {}) {
+		const { method = "GET", headers = {}, body } = options;
+		const fetchOptions = {
+			method,
+			headers
+		};
+		if (body) fetchOptions.body = body;
+		return await fetch(`${this.baseUrl}${endpoint}`, fetchOptions);
+	}
+};
+var BaseResource = class {
+	constructor(client) {
+		this.client = client;
+	}
+};
+/**
+* Unified Route Configuration
+*
+* This file provides a single source of truth for all API routes.
+* It works in two modes:
+*
+* 1. **Pattern Mode** (for API handlers): Returns route patterns like "/:applicationId/usage"
+* 2. **Builder Mode** (for API client): Returns builder functions that create full URLs
+*
+* Both modes share the same structure and definitions, preventing inconsistencies.
+* Route builders are auto-generated from route definitions - no manual duplication needed.
+*/
+const MOUNT_POINTS = {
+	application: "/api/application",
+	applications: "/api/applications",
+	project: "/api/project",
+	projects: "/api/projects",
+	org: "/api/org",
+	admin: "/api/admin",
+	apiKeys: "/api/api-keys",
+	auth: "/api/auth",
+	config: "/config",
+	webSettings: "/web-settings",
+	deployments: "/api/deployments"
+};
+/**
+* Define routes with their patterns and mount points
+* Each route has:
+* - pattern: The Hono route pattern (e.g., "/:applicationId/usage")
+* - mount: The mount point key (e.g., "application")
+*/
+const routeDefinitions = {
+	applications: {
+		list: {
+			pattern: "/",
+			mount: "applications"
+		},
+		create: {
+			pattern: "/",
+			mount: "applications"
+		},
+		get: {
+			pattern: "/:applicationId",
+			mount: "application"
+		},
+		update: {
+			pattern: "/:applicationId",
+			mount: "application"
+		},
+		hasDeployments: {
+			pattern: "/has-deployments",
+			mount: "application"
+		},
+		deployments: {
+			create: {
+				pattern: "/:applicationId/deployments",
+				mount: "application"
+			},
+			latest: {
+				pattern: "/:applicationId/deployment/latest",
+				mount: "application"
+			},
+			byId: {
+				pattern: "/:applicationId/deployment/:deploymentId",
+				mount: "application"
+			},
+			stop: {
+				pattern: "/:applicationId/deployment/stop",
+				mount: "application"
+			},
+			usage: {
+				pattern: "/:applicationId/deployment/:deploymentId/usage",
+				mount: "application"
+			}
+		},
+		usage: {
+			get: {
+				pattern: "/:applicationId/usage",
+				mount: "application"
+			},
+			range: {
+				pattern: "/:applicationId/usage/range",
+				mount: "application"
+			},
+			execution: {
+				pattern: "/:applicationId/execution-usage",
+				mount: "application"
+			},
+			executionUnitsCurrentMonth: {
+				pattern: "/:applicationId/execution-units/current-month",
+				mount: "application"
+			}
+		},
+		runs: {
+			list: {
+				pattern: "/:applicationId/runs",
+				mount: "application"
+			},
+			breakdown: {
+				pattern: "/:applicationId/runs/breakdown",
+				mount: "application"
+			},
+			durationHistogram: {
+				pattern: "/:applicationId/runs/duration-histogram",
+				mount: "application"
+			}
+		},
+		secrets: {
+			list: {
+				pattern: "/:applicationId/secrets",
+				mount: "application"
+			},
+			upsert: {
+				pattern: "/:applicationId/secrets",
+				mount: "application"
+			},
+			delete: {
+				pattern: "/:applicationId/secrets/:secretName",
+				mount: "application"
+			}
+		},
+		logs: { get: {
+			pattern: "/:applicationId/logs",
+			mount: "application"
+		} }
+	},
+	projects: {
+		list: {
+			pattern: "/",
+			mount: "projects"
+		},
+		create: {
+			pattern: "/",
+			mount: "projects"
+		},
+		get: {
+			pattern: "/:projectId/applications",
+			mount: "project"
+		},
+		update: {
+			pattern: "/:projectId",
+			mount: "project"
+		},
+		executionUnitsCurrentMonth: {
+			pattern: "/:projectId/execution-units/current-month",
+			mount: "project"
+		}
+	},
+	organizations: {
+		get: {
+			pattern: "/",
+			mount: "org"
+		},
+		applications: {
+			pattern: "/applications",
+			mount: "org"
+		},
+		update: {
+			pattern: "/:organizationId",
+			mount: "org"
+		},
+		executionUnitsCurrentMonth: {
+			pattern: "/execution-units/current-month",
+			mount: "org"
+		}
+	},
+	apiKeys: {
+		list: {
+			pattern: "/",
+			mount: "apiKeys"
+		},
+		create: {
+			pattern: "/",
+			mount: "apiKeys"
+		},
+		update: {
+			pattern: "/:apiKeyId",
+			mount: "apiKeys"
+		},
+		delete: {
+			pattern: "/:apiKeyId",
+			mount: "apiKeys"
+		}
+	},
+	auth: { test: {
+		pattern: "/test",
+		mount: "auth"
+	} },
+	deployments: {
+		get: {
+			pattern: "/:deploymentId",
+			mount: "deployments"
+		},
+		runs: {
+			pattern: "/:deploymentId/runs",
+			mount: "deployments"
+		}
+	},
+	admin: {
+		users: { create: {
+			pattern: "/users",
+			mount: "admin"
+		} },
+		organizations: {
+			list: {
+				pattern: "/organizations",
+				mount: "admin"
+			},
+			create: {
+				pattern: "/organizations",
+				mount: "admin"
+			},
+			get: {
+				pattern: "/organizations/:organizationId",
+				mount: "admin"
+			}
+		},
+		config: { pumpImageTag: {
+			pattern: "/config/pump-image-tag",
+			mount: "admin"
+		} }
+	},
+	config: {
+		validateYaml: {
+			pattern: "/validate-yaml",
+			mount: "config"
+		},
+		setGlobalKey: {
+			pattern: "/:key",
+			mount: "config"
+		}
+	},
+	webSettings: { get: {
+		pattern: "/",
+		mount: "webSettings"
+	} }
+};
+function extractPatterns(obj) {
+	if (obj.pattern !== void 0) return obj.pattern;
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) result[key] = extractPatterns(value);
+	return result;
+}
+Object.entries(routeDefinitions).reduce((acc, [key, value]) => {
+	acc[key] = extractPatterns(value);
+	return acc;
+}, {});
+/**
+* Build URL from pattern and mount point, substituting parameters in order
+*/
+function buildUrl(pattern, mount, ...params) {
+	let url = pattern === "/" ? mount : mount + pattern;
+	for (const param of params) url = url.replace(/:[^/]+/, param);
+	return url;
+}
+/**
+* Recursively create route builders from route definitions
+*/
+function createRouteBuilders(definitions, mountPoints) {
+	const result = {};
+	for (const [key, value] of Object.entries(definitions)) if (value && typeof value === "object" && "pattern" in value && "mount" in value) {
+		const { pattern, mount } = value;
+		result[key] = (...params) => buildUrl(pattern, mountPoints[mount], ...params);
+	} else if (value && typeof value === "object") result[key] = createRouteBuilders(value, mountPoints);
+	return result;
+}
+/**
+* Route builders for API client (client-side)
+* Auto-generated from routeDefinitions - parameter count is inferred from pattern
+*
+* Usage: this.client.get(routes.applications.usage.get(applicationId))
+*/
+const routes = createRouteBuilders(routeDefinitions, MOUNT_POINTS);
+var ApplicationSecretsResource = class extends BaseResource {
+	/**
+	* Get all secrets for an application
+	*/
+	async list(applicationId) {
+		return this.client["withResult"](() => this.client["get"](routes.applications.secrets.list(applicationId)).then((res) => res.data));
+	}
+	/**
+	* Create or update a secret for an application
+	*/
+	async upsert(applicationId, secretData) {
+		return this.client["withResult"](() => this.client["post"](routes.applications.secrets.upsert(applicationId), secretData).then((res) => res.data));
+	}
+	/**
+	* Delete a secret for an application
+	*/
+	async delete(applicationId, secretName) {
+		return this.client["withResult"](() => this.client["delete"](routes.applications.secrets.delete(applicationId, secretName)).then((res) => res.data));
+	}
+};
+var ApplicationLogsResource = class extends BaseResource {
+	/**
+	* Get logs for an application
+	*/
+	async get(applicationId, options) {
+		const params = new URLSearchParams();
+		if (options?.limit !== void 0) params.append("limit", options.limit.toString());
+		if (options?.offset !== void 0) params.append("offset", options.offset.toString());
+		if (options?.timestamp) params.append("timestamp", options.timestamp);
+		if (options?.level) params.append("level", options.level);
+		if (options?.deploymentId) params.append("deploymentId", options.deploymentId);
+		if (options?.runId) params.append("runId", options.runId);
+		const queryString = params.toString();
+		const endpoint = `${routes.applications.logs.get(applicationId)}${queryString ? `?${queryString}` : ""}`;
+		return this.client["withResult"](() => this.client["get"](endpoint).then((res) => res.data));
+	}
+};
+var ApplicationUsageResource = class extends BaseResource {
+	/**
+	* Get application usage summary
+	*/
+	async get(applicationId) {
+		return this.client["withResult"](async () => {
+			return (await this.client["get"](routes.applications.usage.get(applicationId))).data;
+		});
+	}
+	/**
+	* Get billing usage by time range
+	*/
+	async getByTimeRange(applicationId, startDate, endDate, customRange = null) {
+		return this.client["withResult"](async () => {
+			const baseUrl = this.client["baseUrl"];
+			const url = new URL(routes.applications.usage.range(applicationId), baseUrl);
+			if (startDate) url.searchParams.append("startDate", startDate);
+			if (endDate) url.searchParams.append("endDate", endDate);
+			if (customRange) url.searchParams.append("customRange", customRange);
+			return (await this.client["get"](url.pathname + url.search)).data;
+		});
+	}
+	/**
+	* Get execution usage by application id
+	*/
+	async getExecutionUsage(applicationId) {
+		return this.client["withResult"](async () => {
+			return (await this.client["get"](routes.applications.usage.execution(applicationId))).data;
+		});
+	}
+	/**
+	* Get execution units for an application for the current month
+	*/
+	async getExecutionUnitsCurrentMonth(applicationId) {
+		return this.client["withResult"](async () => {
+			return (await this.client["get"](routes.applications.usage.executionUnitsCurrentMonth(applicationId))).data;
+		});
+	}
+};
+var ApplicationRunsResource = class extends BaseResource {
+	/**
+	* Get application runs
+	*/
+	async list(applicationId, options) {
+		const params = new URLSearchParams();
+		if (options?.limit !== void 0) params.append("limit", options.limit.toString());
+		if (options?.offset !== void 0) params.append("offset", options.offset.toString());
+		const queryString = params.toString();
+		const endpoint = `${routes.applications.runs.list(applicationId)}${queryString ? `?${queryString}` : ""}`;
+		return this.client["withResult"](() => this.client["get"](endpoint).then((res) => res.data));
+	}
+	/**
+	* Get application runs breakdown (success vs failure)
+	*/
+	async getBreakdown(applicationId) {
+		return this.client["withResult"](() => this.client["get"](routes.applications.runs.breakdown(applicationId)).then((res) => res.data));
+	}
+	/**
+	* Get application run duration histogram
+	*/
+	async getDurationHistogram(applicationId, period = "current-month") {
+		const params = new URLSearchParams();
+		params.append("period", period);
+		const queryString = params.toString();
+		const endpoint = `${routes.applications.runs.durationHistogram(applicationId)}?${queryString}`;
+		return this.client["withResult"](() => this.client["get"](endpoint).then((res) => res.data));
+	}
+};
+var ApplicationsResource = class extends BaseResource {
+	secrets;
+	logs;
+	usage;
+	runs;
+	constructor(client) {
+		super(client);
+		this.secrets = new ApplicationSecretsResource(client);
+		this.logs = new ApplicationLogsResource(client);
+		this.usage = new ApplicationUsageResource(client);
+		this.runs = new ApplicationRunsResource(client);
+	}
+	/**
+	* Get all applications in the organization
+	*/
+	async list() {
+		return this.client["withResult"](() => this.client["get"](routes.applications.list()).then((res) => ({ applications: res.data })));
+	}
+	/**
+	* Get application details
+	*/
+	async get(applicationId) {
+		return this.client["withResult"](() => this.client["get"](routes.applications.get(applicationId)));
+	}
+	/**
+	* Create a new application
+	*/
+	async create(data) {
+		return this.client["withResult"](() => this.client["post"](routes.applications.create(), data));
+	}
+	/**
+	* Update application details
+	*/
+	async update(applicationId, data) {
+		return this.client["withResult"](() => this.client["patch"](routes.applications.update(applicationId), data));
+	}
+	/**
+	* Check if any deployment exists in the organization
+	*/
+	async hasDeployments() {
+		return this.client["withResult"](() => this.client["get"](routes.applications.hasDeployments()));
+	}
+};
+var ProjectsResource = class extends BaseResource {
+	/**
+	* Get all projects in the organization
+	*/
+	async list() {
+		return this.client["withResult"](() => this.client["get"](routes.projects.list()));
+	}
+	/**
+	* Get project details with applications
+	*/
+	async get(projectId) {
+		return this.client["withResult"](() => this.client["get"](routes.projects.get(projectId)));
+	}
+	/**
+	* Create a new project
+	*/
+	async create(data) {
+		return this.client["withResult"](() => this.client["post"](routes.projects.create(), data));
+	}
+	/**
+	* Update project details
+	*/
+	async update(projectId, data) {
+		return this.client["withResult"](() => this.client["patch"](routes.projects.update(projectId), data));
+	}
+	/**
+	* Get execution units for a project for the current month
+	*/
+	async getExecutionUnitsCurrentMonth(projectId) {
+		return this.client["withResult"](async () => {
+			return (await this.client["get"](routes.projects.executionUnitsCurrentMonth(projectId))).data;
+		});
+	}
+};
+var OrganizationsResource = class extends BaseResource {
+	/**
+	* Get current organization
+	*/
+	async get() {
+		return this.client["withResult"](() => this.client["get"](routes.organizations.get()));
+	}
+	/**
+	* Update organization details
+	*/
+	async update(organizationId, data) {
+		return this.client["withResult"](() => this.client["patch"](routes.organizations.update(organizationId), data));
+	}
+	/**
+	* Get execution units for the organization for the current month
+	*/
+	async getExecutionUnitsCurrentMonth() {
+		return this.client["withResult"](async () => {
+			return (await this.client["get"](routes.organizations.executionUnitsCurrentMonth())).data;
+		});
+	}
+};
+var AdminOrganizationsResource = class extends BaseResource {
+	/**
+	* Create a new organization (admin only)
+	*/
+	async create(organizationData) {
+		return this.client["withResult"](() => this.client["post"](routes.admin.organizations.create(), organizationData).then((response) => response.data.organization));
+	}
+	/**
+	* Get organization details by ID (admin only)
+	*/
+	async get(organizationId) {
+		return this.client["withResult"](async () => {
+			return (await this.client["get"](routes.admin.organizations.get(organizationId))).data;
+		});
+	}
+	/**
+	* List all organizations (admin only)
+	*/
+	async list() {
+		return this.client["withResult"](async () => {
+			return (await this.client["get"](routes.admin.organizations.list())).data;
+		});
+	}
+};
+var DeploymentsResource = class extends BaseResource {
+	/**
+	* Create a new deployment
+	*/
+	async create({ applicationId, configYaml }) {
+		const requestBody = {
+			applicationId,
+			config: configYaml,
+			name: `deployment-${Date.now()}`,
+			force: false
+		};
+		return this.client["withResult"](() => this.client["post"](routes.applications.deployments.create(applicationId), requestBody));
+	}
+	/**
+	* Get latest deployment for application
+	* Returns { data: Deployment | null } where null indicates no deployment exists
+	*/
+	async getLatest(applicationId) {
+		return this.client["withResult"](() => this.client["get"](routes.applications.deployments.latest(applicationId)));
+	}
+	/**
+	* Get a deployment by ID
+	*/
+	async get(deploymentId) {
+		return this.client["withResult"](() => this.client["get"](routes.deployments.get(deploymentId)));
+	}
+	/**
+	* Stop running deployment for application
+	*/
+	async stop(applicationId) {
+		return this.client["withResult"](() => this.client["post"](routes.applications.deployments.stop(applicationId)));
+	}
+	async getRuns(deploymentId, limit) {
+		const queryString = limit ? `?limit=${limit}` : "";
+		const endpoint = `${routes.deployments.runs(deploymentId)}${queryString}`;
+		return this.client["withResult"](() => this.client["get"](endpoint));
+	}
+};
+var ApiKeysResource = class extends BaseResource {
+	/**
+	* Get all API keys for the organization
+	*/
+	async list() {
+		return this.client["withResult"](() => this.client["get"](routes.apiKeys.list()));
+	}
+	/**
+	* Create a new API key
+	*/
+	async create(data) {
+		return this.client["withResult"](() => this.client["post"](routes.apiKeys.create(), data));
+	}
+	/**
+	* Update an API key
+	*/
+	async update(apiKeyId, data) {
+		return this.client["withResult"](() => this.client["patch"](routes.apiKeys.update(apiKeyId), data));
+	}
+	/**
+	* Delete an API key
+	*/
+	async delete(apiKeyId) {
+		return this.client["withResult"](() => this.client["delete"](routes.apiKeys.delete(apiKeyId)));
+	}
+};
+var AdminUsersResource = class extends BaseResource {
+	/**
+	* Create a new user (admin only)
+	*/
+	async create(userData) {
+		return this.client["withResult"](() => this.client["post"](routes.admin.users.create(), userData).then((response) => response.data.user));
+	}
+};
+var AdminResource = class extends BaseResource {
+	users;
+	organizations;
+	constructor(client) {
+		super(client);
+		this.users = new AdminUsersResource(client);
+		this.organizations = new AdminOrganizationsResource(client);
+	}
+};
+const postMessageKeyMapping = {
+	helmRepoUrl: "HELM_REPO_URL",
+	helmRepoUsername: "HELM_REPO_USERNAME",
+	helmRepoPassword: "HELM_REPO_PASSWORD",
+	s3Endpoint: "S3_ENDPOINT",
+	s3BucketName: "S3_BUCKET_NAME",
+	s3AccessKeyId: "S3_ACCESS_KEY_ID",
+	s3SecretAccessKey: "S3_SECRET_ACCESS_KEY",
+	s3Region: "S3_REGION",
+	pumpImageTag: "PUMP_IMAGE_TAG"
+};
+var ConfigResource = class extends BaseResource {
+	/**
+	* Validate config YAML
+	*/
+	async validateYaml(configYaml) {
+		const responseJson = await (await this.client["makeUnauthenticatedRequest"](routes.config.validateYaml(), {
+			method: "POST",
+			headers: { "Content-Type": "application/x-yaml" },
+			body: configYaml
+		})).json();
+		if (responseJson.valid) return Result2.ok(responseJson);
+		else return Result2.error(new InvalidYamlError("YAML validation failed", responseJson.errors));
+	}
+	/**
+	* Get web settings
+	*/
+	async getWebSettings() {
+		const response = await this.client["makeUnauthenticatedRequest"](routes.webSettings.get(), { method: "GET" });
+		if (!response.ok) {
+			const errorData = await response.json();
+			return Result2.error(new ApiError(errorData.error, { error: errorData.error }));
+		}
+		const data = await response.json();
+		return Result2.ok(data);
+	}
+	/**
+	* Set a global config key
+	*/
+	async setGlobalKey(key, value) {
+		if (!(key in postMessageKeyMapping)) return Result2.error(new ApiError(`Invalid key: ${key}`, { error: `Invalid key: ${key}. Must be one of: ${Object.keys(postMessageKeyMapping).join(", ")}` }));
+		if (key === "pumpImageTag") return this.client["withResult"](() => this.client["post"](routes.admin.config.pumpImageTag(), { pumpImageTag: value }));
+		const mappedKey = postMessageKeyMapping[key];
+		return this.client["withResult"](() => this.client["post"](routes.config.setGlobalKey(mappedKey), { value }));
+	}
+};
+var AuthResource = class extends BaseResource {
+	/**
+	* Test authentication
+	*/
+	async test() {
+		return this.client["withResult"](() => this.client["get"](routes.auth.test()));
+	}
+};
+var ApiClient = class extends BaseClient {
+	applications;
+	projects;
+	organizations;
+	deployments;
+	apiKeys;
+	admin;
+	config;
+	auth;
+	constructor(baseUrl, apiKey) {
+		super(baseUrl, apiKey);
+		this.applications = new ApplicationsResource(this);
+		this.projects = new ProjectsResource(this);
+		this.organizations = new OrganizationsResource(this);
+		this.deployments = new DeploymentsResource(this);
+		this.apiKeys = new ApiKeysResource(this);
+		this.admin = new AdminResource(this);
+		this.config = new ConfigResource(this);
+		this.auth = new AuthResource(this);
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'ApiClient', {
+  enumerable: true,
+  get: function () {
+    return ApiClient;
+  }
+});