@akterjs/cli 0.0.0-stage → 0.1.1

package/dist/cloud-client.adapter-Cy1BjDbG.mjs

@@ -0,0 +1,3186 @@
+import { n as Error } from "./Data-CeCULr0-.mjs";
+import { $t as suspend, B as flatMap, Dt as orElseSucceed, E as contextWith, Kr as hasInterrupts, M as fail, N as failCause, Vn as effect, Xi as DisablePropagation, Xt as succeed, aa as Service, bn as withParentSpan, dt as map, en as sync, gn as void_, ha as merge, hn as useSpan, ia as Reference, mn as updateContext, or as TracerTimingEnabled, pn as uninterruptibleMask, vt as matchCauseEffect, wt as onInterrupt, xr as fail$1, yn as withFiber } from "./Effect-CKFpqbmw.mjs";
+import { $t as isUnique, Ct as isFinite, Dt as isGreaterThanOrEqualTo, F as String$1, Ft as isLessThanOrEqualTo, Gn as CurrentRedactedNames, I as Struct, In as CurrentRedactedNames$1, Jn as fromRecordUnsafe, Jt as isPropertyNames, M as Record, Rt as isMaxCodePoints, S as Literals, U as Tuple, Ut as isMinLength, W as TupleWithRest, Xn as isRedactedName, Y as Union, a as Boolean, an as optionalKey, g as Finite, jt as isInt, k as Number$1, n as ArraySchema, qt as isPattern, rn as makeFilterGroup, v as Int, wt as isGreaterThan, x as Literal, zn as redactUrl } from "./Schema-MiKt5K1v.mjs";
+import { J as suspend$1, d as ensuring, nt as unwrap } from "./Stream-bK9QIETN.mjs";
+import { C as put, E as setUrlParams, N as Clock, O as make$3, a as WebSourceSymbol, b as patch, c as TypeId$2, g as del, i as matchStatus, m as bodyJsonUnsafe, n as filterStatusOk$1, o as getWebSource, t as TypeId$1, u as schemaBodyJson, v as get, w as setHeaders, x as post, y as make$2 } from "./HttpClientResponse-D5ZKICVV.mjs";
+import { Ct as NodeInspectSymbol, On as pipeArguments, bn as dual, bt as setStackTraceLimit, gn as constTrue, hn as constFalse, m as getOrUndefined, x as match, xt as BaseProto, yt as getStackTraceLimit } from "./Option-DkxSnBhp.mjs";
+import { $ as isFailure } from "./Array-B4kuTQeW.mjs";
+import { i as HttpClientError, o as InvalidUrlError, s as StatusCodeError } from "./HttpClientError-BUeMWx70.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/http/HttpMethod.js
+/**
+* Provides a readonly set containing every supported `HttpMethod` literal.
+*
+* **When to use**
+*
+* Use when you need to iterate over or test membership against every supported
+* HTTP method literal.
+*
+* @stability unstable
+* @category constants
+* @since 4.0.0
+*/
+const all = /*#__PURE__*/ new Set([
+	"GET",
+	"POST",
+	"PUT",
+	"DELETE",
+	"PATCH",
+	"HEAD",
+	"OPTIONS",
+	"TRACE",
+	"QUERY"
+]);
+/**
+* Provides tuples mapping each supported HTTP method to its short
+* request-constructor name.
+*
+* **When to use**
+*
+* Use when you need the mapping from supported HTTP method literals to their
+* short request-constructor names.
+*
+* @stability unstable
+* @category constants
+* @since 4.0.0
+*/
+const allShort = [
+	["GET", "get"],
+	["POST", "post"],
+	["PUT", "put"],
+	["DELETE", "del"],
+	["PATCH", "patch"],
+	["HEAD", "head"],
+	["OPTIONS", "options"],
+	["TRACE", "trace"],
+	["QUERY", "query"]
+];
+/**
+* Checks whether a value is a `HttpMethod`.
+*
+* **Example** (Checking HTTP method values)
+*
+* ```ts import.meta.vitest
+* import { HttpMethod } from "effect/http"
+*
+* HttpMethod.isHttpMethod("GET") // => true
+* HttpMethod.isHttpMethod("get") // => false
+* HttpMethod.isHttpMethod(1) // => false
+* ```
+*
+* @stability unstable
+* @category guards
+* @since 4.0.0
+*/
+const isHttpMethod = (u) => all.has(u);
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/http/HttpTraceContext.js
+/**
+* HTTP propagation helpers for Effect tracing context.
+*
+* This module converts Effect `Tracer.Span` values into outbound trace headers
+* and decodes inbound propagation headers into `Tracer.ExternalSpan` parents.
+* HTTP clients use it to continue the current span across outgoing requests, and
+* server middleware uses it to parent request spans from upstream services.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+/**
+* Encodes a span into HTTP trace propagation headers.
+*
+* **Details**
+*
+* The generated headers include both compact B3 (`b3`) and W3C `traceparent`
+* formats.
+*
+* @stability unstable
+* @category encoding
+* @since 4.0.0
+*/
+const toHeaders = (span) => fromRecordUnsafe({
+	b3: `${span.traceId}-${span.spanId}-${span.sampled ? "1" : "0"}${match(span.parent, {
+		onNone: () => "",
+		onSome: (parent) => `-${parent.spanId}`
+	})}`,
+	traceparent: `00-${span.traceId.padStart(32, "0")}-${span.spanId}-${span.sampled ? "01" : "00"}`
+});
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/http/internal/tracing.js
+const defaultPorts = {
+	"http:": 80,
+	"https:": 443,
+	"ws:": 80,
+	"wss:": 443
+};
+/**
+* Records `url.*` and `server.*` attributes with URL redaction.
+*
+* @internal
+*/
+const addUrlAttributes = (span, url, redactedNames) => {
+	const query = redactUrl(url.search, redactedNames).slice(1);
+	span.attribute("url.full", redactUrl(url.href, redactedNames));
+	span.attribute("url.path", url.pathname);
+	if (query !== "") span.attribute("url.query", query);
+	span.attribute("url.scheme", url.protocol.slice(0, -1));
+	if (url.hostname !== "") {
+		span.attribute("server.address", url.hostname.startsWith("[") ? url.hostname.slice(1, -1) : url.hostname);
+		const port = url.port === "" ? defaultPorts[url.protocol] : Number(url.port);
+		if (port !== void 0) span.attribute("server.port", port);
+	}
+};
+/**
+* Adds the names of `Redacted` parameters to the redacted names.
+*
+* @internal
+*/
+const redactedNames = (urlParams, redactedNames) => {
+	const keys = urlParams.params.filter(([, value]) => typeof value !== "string").map(([key]) => key);
+	return keys.length === 0 ? redactedNames : [...redactedNames, ...new URLSearchParams(keys.map((key) => [key, ""])).keys()];
+};
+/** @internal */
+const addHeaderAttributes = (span, phase, headers, filter, redactedNames) => {
+	for (const name in headers) {
+		if (!filter(name, phase)) continue;
+		span.attribute(`http.${phase}.header.${name}`, isRedactedName(name, redactedNames) ? "<redacted>" : headers[name]);
+	}
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/http/HttpClient.js
+const TypeId = "~effect/http/HttpClient";
+/**
+* Service tag for the default outgoing HTTP client service.
+*
+* **When to use**
+*
+* Use to provide the default outgoing HTTP client service used by request
+* accessors such as `execute`, `get`, and `post`.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const HttpClient = /*#__PURE__*/ Service("effect/HttpClient");
+/**
+* Transforms a client by applying an effectful transformation to each response effect.
+*
+* @stability unstable
+* @category mapping
+* @since 4.0.0
+*/
+const transformResponse = /*#__PURE__*/ dual(2, (self, f) => makeWith((request) => f(self.postprocess(request)), self.preprocess));
+/**
+* Filters responses that return a 2xx status code.
+*
+* @stability unstable
+* @category filtering
+* @since 4.0.0
+*/
+const filterStatusOk = /*#__PURE__*/ transformResponse(/*#__PURE__*/ flatMap(filterStatusOk$1));
+/**
+* Constructs an `HttpClient.With` from a preprocessing function and a postprocessing function.
+*
+* **Details**
+*
+* `execute` applies preprocessing to the request and then passes the resulting request effect to postprocessing.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const makeWith = (postprocess, preprocess) => {
+	const self = Object.create(Proto);
+	self.preprocess = preprocess;
+	self.postprocess = postprocess;
+	self.execute = function(request) {
+		return postprocess(preprocess(request));
+	};
+	return self;
+};
+const Proto = {
+	[TypeId]: TypeId,
+	pipe() {
+		return pipeArguments(this, arguments);
+	},
+	...BaseProto,
+	toJSON() {
+		return { _id: "effect/HttpClient" };
+	},
+	.../*#__PURE__*/ Object.fromEntries(/*#__PURE__*/ allShort.map(([fullMethod, method]) => [method, function(url, options) {
+		return this.execute(make$2(fullMethod)(url, options));
+	}]))
+};
+/**
+* Constructs an `HttpClient` from a low-level request runner.
+*
+* **Details**
+*
+* The runner receives the request, resolved URL, abort signal, and current fiber. The client wrapper handles URL construction failures, tracing and propagation, header redaction, and aborting non-scoped requests on interruption.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make$1 = (f) => makeWith((effect) => flatMap(effect, (request) => withFiber((fiber) => {
+	const scopedController = scopedRequests.get(request);
+	const controller = scopedController ?? new AbortController();
+	const urlResult = make$3(request.url, request.urlParams, getOrUndefined(request.hash));
+	if (isFailure(urlResult)) return fail(new HttpClientError({ reason: new InvalidUrlError({
+		request,
+		cause: urlResult.failure
+	}) }));
+	const url = urlResult.success;
+	if (fiber.getRef(DisablePropagation) || fiber.getRef(TracerDisabledWhen)(request)) {
+		const effect = f(request, url, controller.signal, fiber);
+		if (scopedController) return map(effect, (response) => trackResponse(response, controller, true));
+		return uninterruptibleMask((restore) => matchCauseEffect(restore(effect), {
+			onSuccess(response) {
+				return succeed(trackResponse(response, controller, false));
+			},
+			onFailure(cause) {
+				if (hasInterrupts(cause)) controller.abort();
+				return failCause(cause);
+			}
+		}));
+	}
+	return useSpan(fiber.getRef(SpanNameGenerator)(request), { kind: "client" }, (span) => {
+		span.attribute("http.request.method", request.method);
+		const redactedHeaderNames = fiber.getRef(CurrentRedactedNames);
+		addUrlAttributes(span, url, redactedNames(request.urlParams, fiber.getRef(CurrentRedactedNames$1)));
+		const headerFilter = fiber.getRef(TracerHeaderFilter);
+		addHeaderAttributes(span, "request", request.headers, headerFilter, redactedHeaderNames);
+		request = fiber.getRef(TracerPropagationEnabled) ? setHeaders(request, toHeaders(span)) : request;
+		return uninterruptibleMask((restore) => restore(f(request, url, controller.signal, fiber)).pipe(withParentSpan(span, { captureStackTrace: false }), matchCauseEffect({
+			onSuccess: (response) => {
+				span.attribute("http.response.status_code", response.status);
+				addHeaderAttributes(span, "response", response.headers, headerFilter, redactedHeaderNames);
+				if (response.status >= 400 && response.status < 600) {
+					span.attribute("error.type", String(response.status));
+					endSpanWithStatusError(fiber, span, request, response);
+				}
+				return succeed(trackResponse(response, controller, scopedController !== void 0));
+			},
+			onFailure(cause) {
+				if (!scopedController && hasInterrupts(cause)) controller.abort();
+				return failCause(cause);
+			}
+		})));
+	});
+})), succeed);
+const endSpanWithStatusError = (fiber, span, request, response) => {
+	const stackTraceLimit = getStackTraceLimit();
+	setStackTraceLimit(0);
+	let exit;
+	try {
+		exit = fail$1(new HttpClientError({ reason: new StatusCodeError({
+			request,
+			response
+		}) }));
+	} finally {
+		setStackTraceLimit(stackTraceLimit);
+	}
+	span.end(fiber.getRef(TracerTimingEnabled) ? fiber.getRef(Clock).currentTimeNanosUnsafe() : BigInt(0), exit);
+};
+/**
+* Appends a transformation of the request object before sending it.
+*
+* @stability unstable
+* @category mapping
+* @since 4.0.0
+*/
+const mapRequest = /*#__PURE__*/ dual(2, (self, f) => makeWith(self.postprocess, (request) => map(self.preprocess(request), f)));
+/**
+* Appends an effectful transformation of the request object before sending it.
+*
+* @stability unstable
+* @category mapping
+* @since 4.0.0
+*/
+const mapRequestEffect = /*#__PURE__*/ dual(2, (self, f) => makeWith(self.postprocess, (request) => flatMap(self.preprocess(request), f)));
+/**
+* Context reference for a predicate that disables client-side tracing for matching outgoing requests.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const TracerDisabledWhen = /*#__PURE__*/ Reference("effect/http/HttpClient/TracerDisabledWhen", { defaultValue: () => constFalse });
+/**
+* Context reference for filtering request and response headers added to client spans.
+*
+* **Details**
+*
+* Header capture is opt-in: the default filter records no headers. Captured
+* headers listed in `Headers.CurrentRedactedNames` are recorded as `<redacted>`.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const TracerHeaderFilter = /*#__PURE__*/ Reference("effect/http/HttpClient/TracerHeaderFilter", { defaultValue: () => constFalse });
+/**
+* Context reference that controls whether outgoing client spans are propagated to request headers.
+*
+* **Details**
+*
+* When this is `true`, the client writes the compact B3 `b3` header and the
+* W3C `traceparent` header. The default is on. The client span is still
+* created when this is `false`.
+*
+* **Gotchas**
+*
+* A browser preflight fails when the target does not list `b3` and
+* `traceparent` in `Access-Control-Allow-Headers`. Set this to `false` for
+* those requests.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const TracerPropagationEnabled = /*#__PURE__*/ Reference("effect/http/HttpClient/TracerPropagationEnabled", { defaultValue: constTrue });
+/**
+* Context reference for generating the span name used for outgoing client request spans.
+*
+* **Details**
+*
+* Defaults to the request method unchanged.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const SpanNameGenerator = /*#__PURE__*/ Reference("effect/http/HttpClient/SpanNameGenerator", { defaultValue: () => (request) => request.method });
+/**
+* Creates an `HttpClient` layer and merges the layer construction context into client response effects.
+*
+* @stability unstable
+* @category layers
+* @since 4.0.0
+*/
+const layerMergedContext = (effect$1) => effect(HttpClient)(contextWith((context) => map(effect$1, (client) => transformResponse(client, updateContext((input) => merge(context, input))))));
+const responseRegistry = /*#__PURE__*/ (() => {
+	if ("FinalizationRegistry" in globalThis && globalThis.FinalizationRegistry) {
+		const registry = /*#__PURE__*/ new FinalizationRegistry((controller) => {
+			try {
+				controller.abort();
+			} catch {}
+		});
+		return {
+			register(response, controller) {
+				registry.register(response, controller, response);
+			},
+			unregister(response) {
+				registry.unregister(response);
+			}
+		};
+	}
+	const timers = /*#__PURE__*/ new WeakMap();
+	return {
+		register(response, controller) {
+			timers.set(response, setTimeout(() => controller.abort(), 5e3));
+		},
+		unregister(response) {
+			const timer = timers.get(response);
+			if (timer === void 0) return;
+			clearTimeout(timer);
+			timers.delete(response);
+		}
+	};
+})();
+const scopedRequests = /*#__PURE__*/ new WeakMap();
+const responseControllers = /*#__PURE__*/ new WeakMap();
+const trackResponse = (response, controller, scoped) => {
+	if (!scoped) {
+		responseRegistry.register(response, controller);
+		response = new InterruptibleResponse(response, controller);
+	}
+	responseControllers.set(response, controller);
+	return response;
+};
+var InterruptibleResponse = class {
+	original;
+	controller;
+	constructor(original, controller) {
+		this.original = original;
+		this.controller = controller;
+	}
+	[TypeId$1] = TypeId$1;
+	[TypeId$2] = TypeId$2;
+	applyInterrupt(effect) {
+		return suspend(() => {
+			responseRegistry.unregister(this.original);
+			return onInterrupt(effect, () => sync(() => {
+				this.controller.abort();
+			}));
+		});
+	}
+	get request() {
+		return this.original.request;
+	}
+	get url() {
+		return this.original.url;
+	}
+	get status() {
+		return this.original.status;
+	}
+	get headers() {
+		return this.original.headers;
+	}
+	get cookies() {
+		return this.original.cookies;
+	}
+	get remoteAddress() {
+		return this.original.remoteAddress;
+	}
+	get formData() {
+		return this.applyInterrupt(this.original.formData);
+	}
+	get text() {
+		return this.applyInterrupt(this.original.text);
+	}
+	get json() {
+		return this.applyInterrupt(this.original.json);
+	}
+	get urlParamsBody() {
+		return this.applyInterrupt(this.original.urlParamsBody);
+	}
+	get arrayBuffer() {
+		return this.applyInterrupt(this.original.arrayBuffer);
+	}
+	get upgrade() {
+		return this.applyInterrupt(this.original.upgrade);
+	}
+	[WebSourceSymbol]() {
+		const source = getWebSource(this.original);
+		if (source !== void 0) responseRegistry.unregister(this.original);
+		return source;
+	}
+	get stream() {
+		return suspend$1(() => {
+			responseRegistry.unregister(this.original);
+			return ensuring(this.original.stream, sync(() => {
+				this.controller.abort();
+			}));
+		});
+	}
+	toJSON() {
+		return this.original.toJSON();
+	}
+	[NodeInspectSymbol]() {
+		return this.original[NodeInspectSymbol]();
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+// .generated/compiled/cloud-client.adapter.js
+const OrganizationName = String$1.annotate({ "description": "An organization's name, unique across Akter Cloud. 1 to 63 characters: a lowercase letter, then lowercase letters, digits or single hyphens, ending in a letter or digit." }).check(isMaxCodePoints(63).annotate({ "expected": "a string with at most 63 code points" })).check(isPattern(new globalThis.RegExp("^[a-z](?:-?[a-z0-9])*$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[a-z](?:-?[a-z0-9])*$",
+	"identifier": "OrganizationName"
+}));
+const UnauthorizedErrorEncoded = Struct({ "_tag": Literal("UnauthorizedError") }).annotate({ "identifier": "UnauthorizedErrorEncoded" });
+const ActorUnavailableErrorEncoded = Struct({
+	"_tag": Literal("ActorUnavailableError"),
+	"reason": String$1
+}).annotate({ "identifier": "ActorUnavailableErrorEncoded" });
+const AuthUnavailableErrorEncoded = Struct({
+	"_tag": Literal("AuthUnavailableError"),
+	"retryAfterSeconds": Number$1.annotate({ "description": "Seconds to wait before retrying, also sent as the Retry-After header." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" }))
+}).annotate({ "identifier": "AuthUnavailableErrorEncoded" });
+const BillingUnavailableErrorEncoded = Struct({
+	"_tag": Literal("BillingUnavailableError"),
+	"retryAfterSeconds": Number$1.annotate({ "description": "Seconds to wait before retrying, also sent as the Retry-After header." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" }))
+}).annotate({ "identifier": "BillingUnavailableErrorEncoded" });
+const BuildStorageUnavailableErrorEncoded = Struct({
+	"_tag": Literal("BuildStorageUnavailableError"),
+	"missing": ArraySchema(String$1).annotate({ "description": "The config this control plane needs to store builds." })
+}).annotate({ "identifier": "BuildStorageUnavailableErrorEncoded" });
+const ExecUnavailableErrorEncoded = Struct({
+	"_tag": Literal("ExecUnavailableError"),
+	"reason": String$1,
+	"retryAfterSeconds": Number$1.annotate({ "description": "Seconds to wait before asking again, also sent as the Retry-After header." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" }))
+}).annotate({ "identifier": "ExecUnavailableErrorEncoded" });
+const AlreadyExistsErrorEncoded = Struct({
+	"_tag": Literal("AlreadyExistsError"),
+	"key": String$1,
+	"resource": Literals([
+		"organization",
+		"member",
+		"api-key",
+		"app",
+		"environment",
+		"snapshot",
+		"build",
+		"deploy",
+		"actor",
+		"domain",
+		"session",
+		"account",
+		"invitation",
+		"approval"
+	])
+}).annotate({ "identifier": "AlreadyExistsErrorEncoded" });
+const ForbiddenErrorEncoded = Struct({
+	"_tag": Literal("ForbiddenError"),
+	"needs": String$1,
+	"reason": optionalKey(String$1.annotate({ "description": "Why the caller can't have it, when a rule refused it outright, such as a key limited to named apps." }))
+}).annotate({ "identifier": "ForbiddenErrorEncoded" });
+const NotFoundErrorEncoded = Struct({
+	"_tag": Literal("NotFoundError"),
+	"key": String$1,
+	"resource": Literals([
+		"organization",
+		"member",
+		"api-key",
+		"app",
+		"environment",
+		"snapshot",
+		"build",
+		"deploy",
+		"actor",
+		"domain",
+		"session",
+		"account",
+		"invitation",
+		"approval"
+	])
+}).annotate({ "identifier": "NotFoundErrorEncoded" });
+const FlagName = String$1.annotate({ "description": "A feature flag's name: a lowercase letter, then 1 to 62 letters or digits, such as cloudFork." }).check(isPattern(new globalThis.RegExp("^[a-z][A-Za-z0-9]{1,62}$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[a-z][A-Za-z0-9]{1,62}$",
+	"identifier": "FlagName"
+}));
+const EnvironmentName = String$1.annotate({ "description": "An environment of an app, such as prod or pr-42. Each environment has its own store. 1 to 63 characters: a lowercase letter, then lowercase letters, digits or single hyphens, ending in a letter or digit." }).check(isMaxCodePoints(63).annotate({ "expected": "a string with at most 63 code points" })).check(isPattern(new globalThis.RegExp("^[a-z](?:-?[a-z0-9])*$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[a-z](?:-?[a-z0-9])*$",
+	"identifier": "EnvironmentName"
+}));
+const InUseReason = Literals([
+	"organizationHasApps",
+	"soleOwner",
+	"environmentHasDomains",
+	"environmentRetired",
+	"environmentNotReady",
+	"environmentReadOnly",
+	"environmentLive",
+	"environmentPromoted",
+	"environmentHasBranches",
+	"snapshotNotReady"
+]).annotate({
+	"description": "organizationHasApps: delete the organization's apps first; soleOwner: the account is the only owner of the organization named by key, so make someone else an owner or delete the organization first; environmentHasDomains: delete the domains that point at the environment named by key first; environmentRetired: the environment named by key was deleted and keeps its name, so neither a deploy nor a new environment can take it; use another name; environmentNotReady: the environment named by key is Branching or Failed, so it can't be promoted or branched from yet; environmentReadOnly: a promote fenced the environment named by key and no promoted environment serves its hostname, so it takes no deploys until it is promoted again; environmentLive: the environment named by key serves another environment's hostname after a promote, so promote that one back before deleting it; environmentPromoted: the environment named by key was promoted and serves the hostname of the environment named by route, so it takes no deploys by its own name; deploy to route, which reaches it; environmentHasBranches: the environment named by key has the live branches named by branches, so delete them first; snapshotNotReady: the snapshot named by key is not Ready, so nothing can branch from it yet.",
+	"identifier": "InUseReason"
+});
+const EnvironmentName_1 = String$1.annotate({ "description": "With environmentPromoted: the environment whose hostname the one named by key now serves." }).check(isMaxCodePoints(63).annotate({ "expected": "a string with at most 63 code points" })).check(isPattern(new globalThis.RegExp("^[a-z](?:-?[a-z0-9])*$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[a-z](?:-?[a-z0-9])*$",
+	"identifier": "EnvironmentName_1"
+}));
+const DangerousOperation = Literals([
+	"account.delete",
+	"actorForks.create",
+	"actors.erase",
+	"apiKeys.revoke",
+	"apiKeys.update",
+	"apps.delete",
+	"billing.cancel",
+	"billing.setCap",
+	"domains.delete",
+	"environments.delete",
+	"environments.promote",
+	"members.remove",
+	"organizations.delete",
+	"secrets.delete",
+	"snapshots.delete"
+]).annotate({
+	"description": "The operation that needs a person's approval. Request one at POST /v1/organizations/{organization}/approvals and send its token as the akter-approval header.",
+	"identifier": "DangerousOperation"
+});
+const ApprovalTarget = String$1.annotate({ "description": "What the operation acts on: its path's values after the organization, joined with /, such as the app's name for apps.delete or shop/prod/DB_URL for secrets.delete; the organization's name for organizations.delete; account for account.delete." }).check(isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(isMaxCodePoints(200).annotate({
+	"expected": "a string with at most 200 code points",
+	"identifier": "ApprovalTarget"
+}));
+Struct({ "displayName": String$1.annotate({ "description": "A name for people to read, 1 to 100 characters." }).check(isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(isMaxCodePoints(100).annotate({ "expected": "a string with at most 100 code points" })) }).annotate({ "identifier": "UpdateOrganization" });
+const AppName = String$1.annotate({ "description": "An app's name, unique within its organization. 1 to 63 characters: a lowercase letter, then lowercase letters, digits or single hyphens, ending in a letter or digit." }).check(isMaxCodePoints(63).annotate({ "expected": "a string with at most 63 code points" })).check(isPattern(new globalThis.RegExp("^[a-z](?:-?[a-z0-9])*$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[a-z](?:-?[a-z0-9])*$",
+	"identifier": "AppName"
+}));
+const Email = String$1.annotate({ "description": "The person who created the key, who is asked to approve its dangerous actions." }).check(isMaxCodePoints(254).annotate({ "expected": "a string with at most 254 code points" })).check(isPattern(new globalThis.RegExp("^[^\\s@]+@[^\\s@]+$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[^\\s@]+@[^\\s@]+$",
+	"identifier": "Email"
+}));
+const ApiKeyId = String$1.annotate({ "description": "An opaque id that starts with key_." }).check(isPattern(new globalThis.RegExp("^key_[0-9a-z]{1,64}$", "u")).annotate({
+	"expected": "a string matching the RegExp ^key_[0-9a-z]{1,64}$",
+	"identifier": "ApiKeyId"
+}));
+const ApiKeyScope = Literals([
+	"deploy",
+	"usage",
+	"call",
+	"read",
+	"export",
+	"delete",
+	"branch",
+	"snapshot",
+	"fork"
+]).annotate({
+	"description": "What a key may do in its organization: deploy its apps, read its usage, call its apps' actors, read their history, export their databases and history, delete its apps, branch an environment, take and delete an environment's snapshots, or fork an actor. A delete, a snapshot delete and a fork still need a person's approval each time.",
+	"identifier": "ApiKeyScope"
+});
+const SpendCap = Number$1.annotate({ "description": "The key's monthly cap in whole US dollars. Every key made since Phase 8 has one; an older key without it is bounded by its organization's cap." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(9007199254740991).annotate({
+	"expected": "a value less than or equal to 9007199254740991",
+	"identifier": "SpendCap"
+}));
+const SpendCap_1 = Number$1.annotate({ "description": "The most the work this key starts may cost in a calendar month, in whole US dollars. Raising it needs a person's confirmation." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(9007199254740991).annotate({
+	"expected": "a value less than or equal to 9007199254740991",
+	"identifier": "SpendCap_1"
+}));
+const DangerousOperation_1 = Literals([
+	"account.delete",
+	"actorForks.create",
+	"actors.erase",
+	"apiKeys.revoke",
+	"apiKeys.update",
+	"apps.delete",
+	"billing.cancel",
+	"billing.setCap",
+	"domains.delete",
+	"environments.delete",
+	"environments.promote",
+	"members.remove",
+	"organizations.delete",
+	"secrets.delete",
+	"snapshots.delete"
+]).annotate({
+	"description": "An operation an API key may run only with a person's approval, named as group.operation like the CLI command and MCP tool.",
+	"identifier": "DangerousOperation_1"
+});
+const ApprovalId = String$1.annotate({ "description": "An opaque id that starts with apr_." }).check(isPattern(new globalThis.RegExp("^apr_[0-9a-z]{1,64}$", "u")).annotate({
+	"expected": "a string matching the RegExp ^apr_[0-9a-z]{1,64}$",
+	"identifier": "ApprovalId"
+}));
+const Email_1 = String$1.annotate({ "description": "The person asked to approve: the key's creator." }).check(isMaxCodePoints(254).annotate({ "expected": "a string with at most 254 code points" })).check(isPattern(new globalThis.RegExp("^[^\\s@]+@[^\\s@]+$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[^\\s@]+@[^\\s@]+$",
+	"identifier": "Email_1"
+}));
+const RateLimitedErrorEncoded = Struct({
+	"_tag": Literal("RateLimitedError"),
+	"retryAfterSeconds": Number$1.annotate({ "description": "Seconds until the limit resets, also sent as the Retry-After header." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" }))
+}).annotate({ "identifier": "RateLimitedErrorEncoded" });
+Struct({ "code": String$1.annotate({ "description": "The 6-digit code from the approval email." }).check(isPattern(new globalThis.RegExp("^\\d{6}$", "u")).annotate({ "expected": "a string matching the RegExp ^\\d{6}$" })) }).annotate({ "identifier": "ConfirmApproval" });
+const ApprovalToken = Struct({
+	"expiresAt": String$1,
+	"token": String$1.annotate({ "description": "Send it once as the akter-approval header of the approved operation on the approved target. It works once and only for the key that asked." })
+}).annotate({ "identifier": "ApprovalToken" });
+const CodeRejection = Literals([
+	"invalid",
+	"expired",
+	"tooManyAttempts"
+]).annotate({
+	"description": "invalid: wrong, already used, or replaced by a newer code; expired: ask for a new code; tooManyAttempts: the code took too many wrong guesses and no longer works, so ask for a new one.",
+	"identifier": "CodeRejection"
+});
+const AppHostname = String$1.annotate({
+	"description": "The hostname an app's environment answers on over HTTPS, such as shop--prod--acme.akter.run. An environment keeps the hostname its first published deploy got.",
+	"identifier": "AppHostname"
+});
+const SnapshotName = String$1.annotate({ "description": "A named snapshot of an environment, such as before-migration, unique within the environment. 1 to 63 characters: a lowercase letter, then lowercase letters, digits or single hyphens, ending in a letter or digit." }).check(isMaxCodePoints(63).annotate({ "expected": "a string with at most 63 code points" })).check(isPattern(new globalThis.RegExp("^[a-z](?:-?[a-z0-9])*$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[a-z](?:-?[a-z0-9])*$",
+	"identifier": "SnapshotName"
+}));
+const EnvironmentName_2 = String$1.annotate({ "description": "The environment that served the hostname before. It stays read-only, with its data, until deleted." }).check(isMaxCodePoints(63).annotate({ "expected": "a string with at most 63 code points" })).check(isPattern(new globalThis.RegExp("^[a-z](?:-?[a-z0-9])*$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[a-z](?:-?[a-z0-9])*$",
+	"identifier": "EnvironmentName_2"
+}));
+const EnvironmentName_3 = String$1.annotate({ "description": "The environment whose hostname moves: the one a branch came from, or the environment itself when it is promoted back." }).check(isMaxCodePoints(63).annotate({ "expected": "a string with at most 63 code points" })).check(isPattern(new globalThis.RegExp("^[a-z](?:-?[a-z0-9])*$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[a-z](?:-?[a-z0-9])*$",
+	"identifier": "EnvironmentName_3"
+}));
+const PromotionStatus = Literals([
+	"Promoting",
+	"Promoted",
+	"Failed"
+]).annotate({
+	"description": "Promoting: the environment that served the hostname is being fenced, so nothing moved yet. Promoted: the hostname serves this environment. Failed: nothing moved; reason says why, and promoting again retries.",
+	"identifier": "PromotionStatus"
+});
+const EnvironmentStatus = Literals([
+	"Branching",
+	"Ready",
+	"Failed",
+	"Retired"
+]).annotate({
+	"description": "Branching: its store is being made from a snapshot. Ready: deploys land on it, unless it is read-only. Failed: its branch was not made; reason says why, and it can only be deleted. Retired: it was deleted, so it serves nothing and takes no deploys; its data is kept but never reattached, and it keeps its name.",
+	"identifier": "EnvironmentStatus"
+});
+const SnapshotStatus = Literals([
+	"Pending",
+	"Ready",
+	"Failed",
+	"Retired"
+]).annotate({
+	"description": "Pending: the checkpoint is being taken. Ready: it holds the environment's data as of takenAt. Failed: no snapshot was taken; reason says why. Retired: it was deleted and can't be used, but the storage provider keeps its data until it can be removed.",
+	"identifier": "SnapshotStatus"
+});
+const Sha256 = String$1.annotate({ "description": "A SHA-256 digest as 64 lowercase hex characters." }).check(isPattern(new globalThis.RegExp("^[0-9a-f]{64}$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[0-9a-f]{64}$",
+	"identifier": "Sha256"
+}));
+const BuildId = String$1.annotate({ "description": "An opaque id that starts with bld_." }).check(isPattern(new globalThis.RegExp("^bld_[0-9a-z]{1,64}$", "u")).annotate({
+	"expected": "a string matching the RegExp ^bld_[0-9a-z]{1,64}$",
+	"identifier": "BuildId"
+}));
+const Sha256_1 = String$1.annotate({ "description": "The SHA-256 of the actor's entry in contracts.json." }).check(isPattern(new globalThis.RegExp("^[0-9a-f]{64}$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[0-9a-f]{64}$",
+	"identifier": "Sha256_1"
+}));
+const BuildStatus = Literals([
+	"Uploading",
+	"Building",
+	"Ready",
+	"Failed"
+]).annotate({ "identifier": "BuildStatus" });
+const BuildUpload = Struct({
+	"expiresAt": String$1,
+	"headers": Record(String$1, String$1).annotate({ "description": "Send these headers with the PUT." }),
+	"url": String$1.annotate({ "description": "PUT the build here before expiresAt." })
+}).annotate({
+	"description": "Absent when the app already stores a build with this digest.",
+	"identifier": "BuildUpload"
+});
+const DeployId = String$1.annotate({ "description": "An opaque id that starts with dep_." }).check(isPattern(new globalThis.RegExp("^dep_[0-9a-z]{1,64}$", "u")).annotate({
+	"expected": "a string matching the RegExp ^dep_[0-9a-z]{1,64}$",
+	"identifier": "DeployId"
+}));
+const DeployStatus = Literals([
+	"Queued",
+	"Building",
+	"Rolling",
+	"Live",
+	"NotServing",
+	"RollingBack",
+	"RolledBack"
+]).annotate({
+	"description": "Where the deploy is in its lifecycle. Live, NotServing and RolledBack are final. NotServing means the build was published but not every shard had a serving host within 15 minutes; a new deploy replaces it.",
+	"identifier": "DeployStatus"
+});
+const NotServingReason = Union([
+	Struct({ "code": Literal("no-answer") }),
+	Struct({ "code": Literal("no-host") }),
+	Struct({ "code": Literal("no-host-up") }),
+	Struct({
+		"code": Literal("load-failed"),
+		"message": String$1
+	}),
+	Struct({
+		"ceiling": Int.check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" })),
+		"code": Literal("host-ceiling"),
+		"hosts": Int.check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" }))
+	}),
+	Struct({
+		"code": Literal("owners-missing"),
+		"published": Int.check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" })),
+		"serving": Int.check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" })),
+		"shards": Int.check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" }))
+	})
+]).annotate({
+	"description": "Why a NotServing deploy isn't serving: the control plane never answered, no host, no host up, the app failed to load (the first line of its message, without paths or credentials, at most 1,024 characters), the environment already holds as many hosts as its ceiling allows and a new one waits for a release, or shards without a serving, published owner.",
+	"identifier": "NotServingReason"
+});
+const RollbackReason = Struct({ "code": Literals([
+	"build-refused",
+	"build-not-ready",
+	"build-mismatch",
+	"build-unsupported",
+	"store-unavailable",
+	"target-changed",
+	"link-outside-disk",
+	"superseded",
+	"failed"
+]) }).annotate({
+	"description": "Why a RolledBack deploy rolled back: the build edits a migration the live build applied or another deploy held the environment, the build wasn't ready, its bytes didn't match its digest, it was built with an Akter release these hosts don't serve, the app's disk was unavailable, the app's disk or hostname changed under it, a link in the disk's .akter folder leads outside the disk, a newer deploy published first, or Akter failed to publish it. New codes may be added.",
+	"identifier": "RollbackReason"
+});
+const DeployInFlightErrorEncoded = Struct({
+	"_tag": Literal("DeployInFlightError"),
+	"app": String$1,
+	"deploy": String$1,
+	"environment": String$1
+}).annotate({ "identifier": "DeployInFlightErrorEncoded" });
+const MigrationEditedErrorEncoded = Struct({
+	"_tag": Literal("MigrationEditedError"),
+	"actor": String$1,
+	"environment": String$1,
+	"number": Int.check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" }))
+}).annotate({ "identifier": "MigrationEditedErrorEncoded" });
+const CustomerHostname = String$1.annotate({ "description": "A hostname you own, such as app.example.com. Names under akter.run are Akter's own." }).check(isPattern(new globalThis.RegExp("^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z](?:[a-z0-9-]{0,61}[a-z0-9])?$", "u")).annotate({
+	"expected": "a string matching the RegExp ^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z](?:[a-z0-9-]{0,61}[a-z0-9])?$",
+	"identifier": "CustomerHostname"
+}));
+const DeployId_1 = String$1.annotate({ "description": "Only the lines about this deploy." }).check(isPattern(new globalThis.RegExp("^dep_[0-9a-z]{1,64}$", "u")).annotate({
+	"expected": "a string matching the RegExp ^dep_[0-9a-z]{1,64}$",
+	"identifier": "DeployId_1"
+}));
+const LogSource = Literals(["deploy", "computer"]).annotate({
+	"description": "What wrote the line: deploy for a deploy's lifecycle, computer for what happened to one of an actor's computers.",
+	"identifier": "LogSource"
+});
+const LogLevel = Literals([
+	"info",
+	"warning",
+	"error"
+]).annotate({ "identifier": "LogLevel" });
+Struct({ "value": String$1.annotate({ "description": "The secret's value, up to 64 KiB. It is sealed at once and never returned." }).check(isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(isMaxCodePoints(65536).annotate({ "expected": "a string with at most 65536 code points" })) }).annotate({ "identifier": "SetSecret" });
+const SecretName = String$1.annotate({ "description": "A secret's name within an environment, as an environment variable: an uppercase letter, then up to 127 uppercase letters, digits or underscores." }).check(isPattern(new globalThis.RegExp("^[A-Z][A-Z0-9_]{0,127}$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[A-Z][A-Z0-9_]{0,127}$",
+	"identifier": "SecretName"
+}));
+const SecretsUnavailableErrorEncoded = Struct({
+	"_tag": Literal("SecretsUnavailableError"),
+	"reason": Literals(["not-configured", "sealing-failed"]).annotate({ "description": "`not-configured` when this control plane has no secrets Worker; `sealing-failed` when it did not answer." })
+}).annotate({ "identifier": "SecretsUnavailableErrorEncoded" });
+const ActorFilter = String$1.annotate({ "description": "Only actors of this name in the app's contract, such as Room." }).check(isMinLength(1).annotate({
+	"expected": "a value with a length of at least 1",
+	"identifier": "ActorFilter"
+}));
+const ActorCursor = String$1.annotate({ "description": "Where a page of actors stopped. Pass the previous page's next unchanged; its contents are not a contract." }).check(isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(isMaxCodePoints(2048).annotate({
+	"expected": "a string with at most 2048 code points",
+	"identifier": "ActorCursor"
+}));
+const ActorEnvironment = String$1.annotate({ "description": "The environment whose actors to list, such as prod, when called at the Cloud API's URL. Defaults to prod. An app's own hostname lists its own environment's actors." }).check(isMaxCodePoints(63).annotate({ "expected": "a string with at most 63 code points" })).check(isPattern(new globalThis.RegExp("^[a-z](?:-?[a-z0-9])*$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[a-z](?:-?[a-z0-9])*$",
+	"identifier": "ActorEnvironment"
+}));
+const ActorType = String$1.annotate({ "description": "The actor's name in the app's contract, such as Room." }).check(isMinLength(1).annotate({
+	"expected": "a value with a length of at least 1",
+	"identifier": "ActorType"
+}));
+const ExportKey = String$1.annotate({
+	"description": "The actor's key, as the app's contract encodes it. The empty key is allowed.",
+	"identifier": "ExportKey"
+});
+const CommandSeq = Number$1.annotate({ "description": "The command's place in the actor's journal, counting from 1." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(9007199254740991).annotate({
+	"expected": "a value less than or equal to 9007199254740991",
+	"identifier": "CommandSeq"
+}));
+const ActorErasedErrorEncoded = Struct({
+	"_tag": Literal("ActorErasedError"),
+	"actor": String$1
+}).annotate({ "identifier": "ActorErasedErrorEncoded" });
+const ExportSnapshotId = String$1.annotate({ "description": "Names one export snapshot of one actor." }).check(isPattern(new globalThis.RegExp("^[0-9a-f]{32}$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[0-9a-f]{32}$",
+	"identifier": "ExportSnapshotId"
+}));
+const ExportSnapshotGoneErrorEncoded = Struct({
+	"_tag": Literal("ExportSnapshotGoneError"),
+	"actor": String$1,
+	"key": String$1,
+	"reason": String$1
+}).annotate({ "identifier": "ExportSnapshotGoneErrorEncoded" });
+const ExecEnvironment = String$1.annotate({ "description": "The environment whose actor runs it, such as prod, when called at the Cloud API's URL. Defaults to prod. An app's own hostname runs its own environment's actor." }).check(isMaxCodePoints(63).annotate({ "expected": "a string with at most 63 code points" })).check(isPattern(new globalThis.RegExp("^[a-z](?:-?[a-z0-9])*$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[a-z](?:-?[a-z0-9])*$",
+	"identifier": "ExecEnvironment"
+}));
+Struct({ "command": String$1.annotate({ "description": "The shell command to run, at most 100 KiB of UTF-8, in /mnt/archil with the actor's files at /mnt/archil/files. There is no standard input." }).check(isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(isMaxCodePoints(102400).annotate({ "expected": "a string with at most 102400 code points" })) }).annotate({ "identifier": "RunExec" });
+const ExecResult = Struct({
+	"executeMs": Number$1.annotate({ "description": "How long the command itself ran, in milliseconds." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" })),
+	"exitCode": Number$1.annotate({ "description": "The command's exit status: 0 when it succeeded." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" })),
+	"queueMs": Number$1.annotate({ "description": "How long the command waited for its machine and disk before it started, in milliseconds." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" })),
+	"stderr": String$1.annotate({ "description": "The command's standard error, its first 4 MiB." }),
+	"stdout": String$1.annotate({ "description": "The command's standard output, its first 4 MiB." })
+}).annotate({
+	"description": "A command that ran to an end.",
+	"identifier": "ExecResult"
+});
+const ExecRefusedErrorEncoded = Struct({
+	"_tag": Literal("ExecRefusedError"),
+	"reason": String$1
+}).annotate({ "identifier": "ExecRefusedErrorEncoded" });
+const ForkId = String$1.annotate({ "description": "Names this fork. A retry with the same id answers the same version and never forks twice; the same id into another key is refused." }).check(isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(isMaxCodePoints(200).annotate({
+	"expected": "a string with at most 200 code points",
+	"identifier": "ForkId"
+}));
+const ActorKey_1 = String$1.annotate({ "description": "The free key the copy is created under. Akter Cloud forks only into a key on the parent's own shard for now." }).check(isMinLength(1).annotate({
+	"expected": "a value with a length of at least 1",
+	"identifier": "ActorKey_1"
+}));
+const ActorKey = String$1.annotate({ "description": "The actor's key, as the app's contract encodes it." }).check(isMinLength(1).annotate({
+	"expected": "a value with a length of at least 1",
+	"identifier": "ActorKey"
+}));
+const Email_2 = String$1.annotate({ "description": "An email address, such as ada@example.com." }).check(isMaxCodePoints(254).annotate({ "expected": "a string with at most 254 code points" })).check(isPattern(new globalThis.RegExp("^[^\\s@]+@[^\\s@]+$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[^\\s@]+@[^\\s@]+$",
+	"identifier": "Email_2"
+}));
+const MemberId = String$1.annotate({ "description": "An opaque id that starts with mem_." }).check(isPattern(new globalThis.RegExp("^mem_[0-9a-z]{1,64}$", "u")).annotate({
+	"expected": "a string matching the RegExp ^mem_[0-9a-z]{1,64}$",
+	"identifier": "MemberId"
+}));
+const Role = Literals([
+	"owner",
+	"admin",
+	"developer",
+	"viewer"
+]).annotate({
+	"description": "owner manages members and billing; admin manages apps and API keys; developer builds and deploys; viewer reads.",
+	"identifier": "Role"
+});
+const InvitationId = String$1.annotate({ "description": "An opaque id that starts with inv_." }).check(isPattern(new globalThis.RegExp("^inv_[0-9a-z]{1,64}$", "u")).annotate({
+	"expected": "a string matching the RegExp ^inv_[0-9a-z]{1,64}$",
+	"identifier": "InvitationId"
+}));
+const AppName_1 = String$1.annotate({ "description": "Only this app's usage." }).check(isMaxCodePoints(63).annotate({ "expected": "a string with at most 63 code points" })).check(isPattern(new globalThis.RegExp("^[a-z](?:-?[a-z0-9])*$", "u")).annotate({
+	"expected": "a string matching the RegExp ^[a-z](?:-?[a-z0-9])*$",
+	"identifier": "AppName_1"
+}));
+const ApiKeyId_1 = String$1.annotate({ "description": "Only the usage this API key started." }).check(isPattern(new globalThis.RegExp("^key_[0-9a-z]{1,64}$", "u")).annotate({
+	"expected": "a string matching the RegExp ^key_[0-9a-z]{1,64}$",
+	"identifier": "ApiKeyId_1"
+}));
+const BillingPeriod = String$1.annotate({ "description": "The month to read. Defaults to this month." }).check(isPattern(new globalThis.RegExp("^\\d{4}-(?:0[1-9]|1[0-2])$", "u")).annotate({
+	"expected": "a string matching the RegExp ^\\d{4}-(?:0[1-9]|1[0-2])$",
+	"identifier": "BillingPeriod"
+}));
+const Usd = Number$1.annotate({ "description": "The organization's spend cap for the month, or the key's when `key` was asked." }).check(isFinite().annotate({
+	"expected": "a finite number",
+	"identifier": "Usd"
+}));
+const UsageMeter = Literals([
+	"commands",
+	"queries",
+	"storage",
+	"snapshots",
+	"computerVcpu",
+	"computerMemory",
+	"execCalls",
+	"egress",
+	"planMinimum"
+]).annotate({ "identifier": "UsageMeter" });
+const Usd_1 = Number$1.annotate({ "description": "US dollars." }).check(isFinite().annotate({
+	"expected": "a finite number",
+	"identifier": "Usd_1"
+}));
+const BillingPeriod_1 = String$1.annotate({ "description": "A calendar month in UTC, YYYY-MM. Usage, caps and invoices are counted per month." }).check(isPattern(new globalThis.RegExp("^\\d{4}-(?:0[1-9]|1[0-2])$", "u")).annotate({
+	"expected": "a string matching the RegExp ^\\d{4}-(?:0[1-9]|1[0-2])$",
+	"identifier": "BillingPeriod_1"
+}));
+const Usd_2 = Number$1.annotate({ "description": "This month's spend so far carried to the month's end at its average rate." }).check(isFinite().annotate({
+	"expected": "a finite number",
+	"identifier": "Usd_2"
+}));
+const Plan = Literals(["none", "usage"]).annotate({
+	"description": "none: no card, a small fixed monthly allowance and no invoices. usage: pay for usage in arrears with a card added on Stripe's page.",
+	"identifier": "Plan"
+});
+const SpendCap_2 = Number$1.annotate({ "description": "The most the organization may spend in a calendar month, in whole US dollars." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(9007199254740991).annotate({
+	"expected": "a value less than or equal to 9007199254740991",
+	"identifier": "SpendCap_2"
+}));
+const BillingStatus = Literals([
+	"none",
+	"checkoutOpen",
+	"active",
+	"pastDue",
+	"canceled"
+]).annotate({
+	"description": "none: no card yet. checkoutOpen: a checkout link is waiting for a person. active: billed monthly. pastDue: a payment failed; new spend stops after a grace period. canceled: back to no card after a final invoice.",
+	"identifier": "BillingStatus"
+});
+const SpendCap_3 = Number$1.annotate({ "description": "The monthly cap to start the paid plan with. Defaults to the plan's starting cap." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(9007199254740991).annotate({
+	"expected": "a value less than or equal to 9007199254740991",
+	"identifier": "SpendCap_3"
+}));
+const CheckoutLink = Struct({
+	"expiresAt": String$1,
+	"url": String$1.annotate({ "description": "A Stripe-hosted page where a person adds a card. Card details go to Stripe only, never to Akter, the CLI or an agent." })
+}).annotate({ "identifier": "CheckoutLink" });
+const Usd_3 = Number$1.annotate({ "description": "The most an organization without a card may spend in a month." }).check(isFinite().annotate({
+	"expected": "a finite number",
+	"identifier": "Usd_3"
+}));
+const InvoiceStatus = Literals([
+	"draft",
+	"open",
+	"paid",
+	"void",
+	"uncollectible"
+]).annotate({ "identifier": "InvoiceStatus" });
+Struct({ "secret": String$1.annotate({ "description": "An API key's secret, as returned when the key was created, or a session's secret from sign-in." }) }).annotate({ "identifier": "ExchangeApiKey" });
+const IssuedToken = Struct({
+	"expiresAt": String$1,
+	"token": String$1.annotate({ "description": "A bearer JWT that carries the key's organization and scopes, or the signed-in account's email." })
+}).annotate({ "identifier": "IssuedToken" });
+const CodePurpose = Literals(["signIn", "recovery"]).annotate({
+	"description": "signIn emails a code that signs in, creating the account the first time; recovery emails the same kind of code worded for someone who lost their session.",
+	"identifier": "CodePurpose"
+});
+const AcceptedTerms = Struct({
+	"acceptedAt": String$1,
+	"version": String$1.annotate({ "description": "The version of the terms of service and privacy notice, as their `version:` line." })
+}).annotate({
+	"description": "The terms of service and privacy notice the account accepted at sign-up, and when. Accounts made before sign-up asked have none.",
+	"identifier": "AcceptedTerms"
+});
+const AccountId = String$1.annotate({ "description": "An opaque id that starts with usr_." }).check(isPattern(new globalThis.RegExp("^usr_[0-9a-z]{1,64}$", "u")).annotate({
+	"expected": "a string matching the RegExp ^usr_[0-9a-z]{1,64}$",
+	"identifier": "AccountId"
+}));
+const SessionId = String$1.annotate({ "description": "An opaque id that starts with ses_." }).check(isPattern(new globalThis.RegExp("^ses_[0-9a-z]{1,64}$", "u")).annotate({
+	"expected": "a string matching the RegExp ^ses_[0-9a-z]{1,64}$",
+	"identifier": "SessionId"
+}));
+const TermsNotAcceptedErrorEncoded = Struct({
+	"_tag": Literal("TermsNotAcceptedError"),
+	"version": String$1.annotate({ "description": "The current version of the terms of service and privacy notice. Send it as acceptedTerms once the person accepts them; the code still works." })
+}).annotate({ "identifier": "TermsNotAcceptedErrorEncoded" });
+const Organization = Struct({
+	"createdAt": String$1,
+	"displayName": String$1.annotate({ "description": "A name for people to read, 1 to 100 characters." }).check(isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(isMaxCodePoints(100).annotate({ "expected": "a string with at most 100 code points" })),
+	"name": OrganizationName
+}).annotate({ "identifier": "Organization" });
+Struct({
+	"displayName": String$1.annotate({ "description": "A name for people to read, 1 to 100 characters." }).check(isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(isMaxCodePoints(100).annotate({ "expected": "a string with at most 100 code points" })),
+	"name": OrganizationName
+}).annotate({ "identifier": "CreateOrganization" });
+const FeatureNotEnabledErrorEncoded = Struct({
+	"_tag": Literal("FeatureNotEnabledError"),
+	"flag": FlagName
+}).annotate({ "identifier": "FeatureNotEnabledErrorEncoded" });
+const SnapshotLimitErrorEncoded = Struct({
+	"_tag": Literal("SnapshotLimitError"),
+	"environment": EnvironmentName,
+	"limit": Number$1.annotate({ "description": "Snapshots one environment may hold. Deleted snapshots count too, because the storage provider keeps their data until it can be removed; delete the environment to start again." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" }))
+}).annotate({ "identifier": "SnapshotLimitErrorEncoded" });
+const InUseErrorEncoded = Struct({
+	"_tag": Literal("InUseError"),
+	"branches": optionalKey(ArraySchema(EnvironmentName).annotate({ "description": "With environmentHasBranches: the live branches of the environment named by key." })),
+	"key": String$1.annotate({ "description": "What is in the way: an organization's, an environment's or a snapshot's name." }),
+	"reason": InUseReason,
+	"route": optionalKey(EnvironmentName_1)
+}).annotate({ "identifier": "InUseErrorEncoded" });
+const ConfirmationRequiredErrorEncoded = Struct({
+	"_tag": Literal("ConfirmationRequiredError"),
+	"operation": DangerousOperation,
+	"target": ApprovalTarget
+}).annotate({ "identifier": "ConfirmationRequiredErrorEncoded" });
+const ApiKeyApps = TupleWithRest(Tuple([AppName]), [AppName]).annotate({ "description": "Allowed app names in this organization. Omit for organization-wide access. App-restricted keys cannot read organization-wide usage." }).check(isUnique().annotate({
+	"expected": "an array with unique items",
+	"identifier": "ApiKeyApps"
+}));
+Struct({ "name": AppName }).annotate({ "identifier": "CreateApp" });
+Struct({ "spendCap": SpendCap_1 }).annotate({ "identifier": "UpdateApiKey" });
+Struct({ "spendCap": SpendCap_1 }).annotate({ "identifier": "SetOrganizationCap" });
+Struct({
+	"operation": DangerousOperation_1,
+	"target": ApprovalTarget
+}).annotate({ "identifier": "RequestApproval" });
+const ApprovalRequested = Struct({
+	"expiresAt": String$1,
+	"id": ApprovalId,
+	"operation": DangerousOperation_1,
+	"sentTo": Email_1,
+	"target": ApprovalTarget
+}).annotate({
+	"description": "A pending approval. The person it was sent to gets a code by email, and gives it to the agent if they agree.",
+	"identifier": "ApprovalRequested"
+});
+const CodeRejectedErrorEncoded = Struct({
+	"_tag": Literal("CodeRejectedError"),
+	"reason": CodeRejection
+}).annotate({ "identifier": "CodeRejectedErrorEncoded" });
+const App = Struct({
+	"createdAt": String$1,
+	"hostnames": Record(String$1, AppHostname).annotate({ "description": "Each environment's hostname, once a deploy to it has published its build. The app's actors answer at https://<hostname>/rpc." }).check(isPropertyNames(String$1.check(makeFilterGroup([isMaxCodePoints(63).annotate({ "expected": "a string with at most 63 code points" }), isPattern(new globalThis.RegExp("^[a-z](?:-?[a-z0-9])*$", "u")).annotate({ "expected": "a string matching the RegExp ^[a-z](?:-?[a-z0-9])*$" })]).annotate({ "description": "An environment of an app, such as prod or pr-42. Each environment has its own store. 1 to 63 characters: a lowercase letter, then lowercase letters, digits or single hyphens, ending in a letter or digit." }))).annotate({ "expected": "an object with property names matching the schema" })),
+	"name": AppName,
+	"organization": OrganizationName
+}).annotate({ "identifier": "App" });
+const EnvironmentOrigin = Struct({
+	"environment": EnvironmentName,
+	"snapshot": SnapshotName
+}).annotate({
+	"description": "Where a branched environment came from: the environment and its Ready snapshot whose data it started with.",
+	"identifier": "EnvironmentOrigin"
+});
+const EnvironmentOrigin_1 = Struct({
+	"environment": EnvironmentName,
+	"snapshot": SnapshotName
+}).annotate({
+	"description": "Branch the new environment from a Ready snapshot: it starts with the snapshot's data, quiet, until it is promoted.",
+	"identifier": "EnvironmentOrigin_1"
+});
+Struct({ "name": SnapshotName }).annotate({ "identifier": "CreateSnapshot" });
+const Promotion = Struct({
+	"environment": EnvironmentName,
+	"fenced": optionalKey(EnvironmentName_2),
+	"hostname": optionalKey(AppHostname),
+	"missingWrites": String$1.annotate({ "description": "The catch, stated for this promote: which writes the promoted environment does not have and where they stay." }),
+	"reason": optionalKey(String$1.annotate({ "description": "Why a Failed promote moved nothing." })),
+	"route": EnvironmentName_3,
+	"status": PromotionStatus
+}).annotate({
+	"description": "Moving an app's hostname to an environment. The environment that served it is fenced first: its hosts give up their shards and it turns read-only. Then the hostname moves, and the promoted environment's held timers, outbox and jobs start.",
+	"identifier": "Promotion"
+});
+const Snapshot = Struct({
+	"createdAt": String$1,
+	"environment": EnvironmentName,
+	"name": SnapshotName,
+	"reason": optionalKey(String$1.annotate({ "description": "Why a Failed snapshot was not taken." })),
+	"sizeBytes": optionalKey(Number$1.annotate({ "description": "The environment's data size when the snapshot was taken, which it is billed by." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" }))),
+	"status": SnapshotStatus,
+	"takenAt": optionalKey(String$1)
+}).annotate({
+	"description": "A named, point-in-time snapshot of one environment's data. A Ready snapshot is kept until it or its environment is deleted, and is billed by its size as snapshot storage.",
+	"identifier": "Snapshot"
+});
+const BuildMigration = Struct({
+	"number": Int.check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" })),
+	"sha256": Sha256
+}).annotate({
+	"description": "One numbered SQL migration and the SHA-256 of its text.",
+	"identifier": "BuildMigration"
+});
+const ExportedFile = Struct({
+	"bytes": Int.check(isGreaterThanOrEqualTo(0).annotate({ "expected": "a value greater than or equal to 0" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" })),
+	"sha256": Sha256
+}).annotate({
+	"description": "One distinct file the snapshot's database names, by the SHA-256 and size of its content. The paths that name it are in the database.",
+	"identifier": "ExportedFile"
+});
+Struct({
+	"build": BuildId,
+	"environment": EnvironmentName
+}).annotate({ "identifier": "CreateDeploy" });
+const BuildNotReadyErrorEncoded = Struct({
+	"_tag": Literal("BuildNotReadyError"),
+	"build": BuildId
+}).annotate({ "identifier": "BuildNotReadyErrorEncoded" });
+const Deploy = Struct({
+	"app": AppName,
+	"build": BuildId,
+	"createdAt": String$1,
+	"environment": EnvironmentName,
+	"hostname": optionalKey(AppHostname),
+	"id": DeployId,
+	"notices": ArraySchema(DeployStatus),
+	"reason": optionalKey(NotServingReason),
+	"rollbackReason": optionalKey(RollbackReason),
+	"status": DeployStatus,
+	"url": optionalKey(String$1.annotate({ "description": "https://<hostname>, where the app answers once this deploy has published its build." }))
+}).annotate({ "identifier": "Deploy" });
+const Domain = Struct({
+	"cname": Literal("customers.akter.run"),
+	"environment": EnvironmentName,
+	"hostname": CustomerHostname,
+	"status": Literals([
+		"Pending",
+		"Active",
+		"Removing"
+	])
+}).annotate({ "identifier": "Domain" });
+Struct({
+	"environment": EnvironmentName,
+	"hostname": CustomerHostname
+}).annotate({ "identifier": "CreateDomain" });
+const HostnameClaimedErrorEncoded = Struct({
+	"_tag": Literal("HostnameClaimedError"),
+	"hostname": CustomerHostname
+}).annotate({ "identifier": "HostnameClaimedErrorEncoded" });
+const LogLine = Struct({
+	"at": String$1,
+	"level": LogLevel,
+	"message": String$1,
+	"source": LogSource,
+	"subject": String$1.annotate({ "description": "What the line is about: a deploy's id for deploy lines, and <environment>/<Actor>/<key>/<computer> for computer lines." })
+}).annotate({ "identifier": "LogLine" });
+const AppSecret = Struct({
+	"environment": EnvironmentName,
+	"name": SecretName,
+	"updatedAt": Number$1.annotate({ "description": "When the value was last set, in milliseconds since the epoch." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" })),
+	"version": Number$1.annotate({ "description": "Increases each time the value is set." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" }))
+}).annotate({
+	"description": "A secret's name and when it was set. Never its value.",
+	"identifier": "AppSecret"
+});
+const ExportedActor = Struct({
+	"actor": ActorType,
+	"key": ExportKey
+}).annotate({
+	"description": "An actor that has a database on the shard.",
+	"identifier": "ExportedActor"
+});
+const ExportedComputer = Struct({
+	"actor": ActorType,
+	"checkpoint": optionalKey(String$1.annotate({ "description": "The computer's newest checkpoint Akter recorded. It stays in Akter Cloud and can't be downloaded; absent before the first." })),
+	"egress": ArraySchema(String$1).annotate({ "description": "The hosts the computer may reach. Never credentials." }),
+	"image": String$1,
+	"key": ExportKey,
+	"name": String$1.annotate({ "description": "The computer's name, unique within its actor." }),
+	"size": Struct({
+		"memoryMib": Int.check(isGreaterThanOrEqualTo(-9007199254740991).annotate({ "expected": "a value greater than or equal to -9007199254740991" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" })),
+		"vcpu": Finite
+	})
+}).annotate({
+	"description": "A computer an actor on the shard keeps, as Akter Cloud records it. Its disk stays in the Cloud.",
+	"identifier": "ExportedComputer"
+});
+const CommandEntry = Struct({
+	"at": String$1,
+	"command": String$1.check(isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })),
+	"commandId": String$1.check(isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })),
+	"exit": String$1.annotate({ "description": "The command's outcome, as JSON text in the app's contract encoding." }),
+	"payload": String$1.annotate({ "description": "The command's payload, as JSON text in the app's contract encoding." }),
+	"principal": String$1.annotate({ "description": "Who sent the command, as JSON text in the app's contract encoding." }),
+	"seq": CommandSeq
+}).annotate({
+	"description": "One journal row, as the host recorded it. Decode it with the app's contract; a row the contract no longer reads is unreadable there, not here.",
+	"identifier": "CommandEntry"
+});
+const ExportSnapshot = Struct({
+	"actor": ActorType,
+	"bytes": Int.check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" })).check(isGreaterThan(0).annotate({ "expected": "a value greater than 0" })),
+	"key": ExportKey,
+	"sha256": Sha256,
+	"snapshot": ExportSnapshotId
+}).annotate({
+	"description": "A consistent snapshot of the actor's database and history, taken after its last commit. Download it as bytes 0 to bytes; the decrypted bytes hash to sha256.",
+	"identifier": "ExportSnapshot"
+});
+Struct({
+	"forkId": ForkId,
+	"into": ActorKey_1
+}).annotate({ "identifier": "ForkActor" });
+const ActorFork = Struct({
+	"into": ActorKey,
+	"version": Number$1.annotate({ "description": "The parent's commit version at the cut: the copy holds the parent's state as of this commit." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(0).annotate({ "expected": "a value greater than or equal to 0" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" }))
+}).annotate({
+	"description": "A copy of the actor under a new key, holding its state and files at the cut and starting quiet: no timers, outbox or open jobs.",
+	"identifier": "ActorFork"
+});
+const CodeSent = Struct({
+	"email": Email_2,
+	"expiresAt": String$1
+}).annotate({ "identifier": "CodeSent" });
+Struct({
+	"acceptedTerms": optionalKey(String$1.annotate({ "description": "The version of the terms of service and privacy notice the person accepted, as the `version:` line of `akter docs legal/terms`. Required when the code creates an account." })),
+	"code": String$1.annotate({ "description": "The 6-digit code from the email." }).check(isPattern(new globalThis.RegExp("^\\d{6}$", "u")).annotate({ "expected": "a string matching the RegExp ^\\d{6}$" })),
+	"email": Email_2,
+	"endOtherSessions": optionalKey(Boolean.annotate({ "description": "Also revoke every other session of the account, as a recovery does after a lost machine." }))
+}).annotate({ "identifier": "VerifyCode" });
+const Member = Struct({
+	"email": Email_2,
+	"id": MemberId,
+	"joinedAt": String$1,
+	"role": Role
+}).annotate({ "identifier": "Member" });
+Struct({
+	"email": Email_2,
+	"role": Role
+}).annotate({ "identifier": "AddMember" });
+Struct({ "role": Role }).annotate({ "identifier": "ChangeRole" });
+Struct({
+	"email": Email_2,
+	"role": Role
+}).annotate({ "identifier": "Invite" });
+const Invitation = Struct({
+	"createdAt": String$1,
+	"email": Email_2,
+	"expiresAt": String$1,
+	"id": InvitationId,
+	"invitedBy": Email_2,
+	"role": Role
+}).annotate({
+	"description": "A pending invitation. The invited email signs in and accepts it to become a member with this role.",
+	"identifier": "Invitation"
+});
+const MeterUsage = Struct({
+	"meter": UsageMeter,
+	"quantity": Number$1.annotate({ "description": "How much was used, in `unit`." }).check(isFinite().annotate({ "expected": "a finite number" })),
+	"spentUsd": Usd_1,
+	"unit": String$1.annotate({ "description": "The unit prices are quoted in: million commands, million queries, GiB-month, vCPU-hour, GiB-hour, thousand calls, GB or USD." })
+}).annotate({ "identifier": "MeterUsage" });
+const UsageForecast = Struct({
+	"capUsd": Usd_1,
+	"period": BillingPeriod_1,
+	"projectedUsd": Usd_2,
+	"spentUsd": Usd_1
+}).annotate({ "identifier": "UsageForecast" });
+const BillingAccount = Struct({
+	"plan": Plan,
+	"spendCap": SpendCap_2,
+	"status": BillingStatus
+}).annotate({ "identifier": "BillingAccount" });
+Struct({ "spendCap": optionalKey(SpendCap_3) }).annotate({ "identifier": "StartCheckout" });
+const CardRequiredErrorEncoded = Struct({
+	"_tag": Literal("CardRequiredError"),
+	"allowanceUsd": Usd_3
+}).annotate({ "identifier": "CardRequiredErrorEncoded" });
+const Invoice = Struct({
+	"amountDueUsd": Usd_1,
+	"amountPaidUsd": Usd_1,
+	"createdAt": String$1,
+	"id": String$1,
+	"period": optionalKey(BillingPeriod_1),
+	"status": InvoiceStatus,
+	"url": optionalKey(String$1.annotate({ "description": "Stripe's page for the invoice." }))
+}).annotate({ "identifier": "Invoice" });
+Struct({
+	"email": Email_2,
+	"purpose": optionalKey(CodePurpose)
+}).annotate({ "identifier": "SendCode" });
+const Account = Struct({
+	"acceptedTerms": optionalKey(AcceptedTerms),
+	"createdAt": String$1,
+	"email": Email_2,
+	"id": AccountId
+}).annotate({ "identifier": "Account" });
+const Session = Struct({
+	"createdAt": String$1,
+	"expiresAt": String$1,
+	"id": SessionId
+}).annotate({ "identifier": "Session" });
+const OrganizationPage = Struct({
+	"items": ArraySchema(Organization),
+	"nextCursor": optionalKey(String$1.annotate({ "description": "Pass as cursor for the next page." }))
+}).annotate({ "identifier": "OrganizationPage" });
+const ApiKey = Struct({
+	"apps": optionalKey(ApiKeyApps),
+	"createdAt": String$1,
+	"createdBy": optionalKey(Email),
+	"expiresAt": optionalKey(String$1.annotate({ "description": "When the key stops getting tokens. Every key made since Phase 8 has one." })),
+	"id": ApiKeyId,
+	"lastUsedAt": optionalKey(String$1),
+	"name": String$1.annotate({ "description": "A name for people to read, 1 to 100 characters." }).check(isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(isMaxCodePoints(100).annotate({ "expected": "a string with at most 100 code points" })),
+	"scopes": TupleWithRest(Tuple([ApiKeyScope]), [ApiKeyScope]).annotate({ "description": "What the key may do: one or more scopes." }),
+	"spendCap": optionalKey(SpendCap),
+	"start": String$1.annotate({ "description": "The first characters of the secret, to tell keys apart." })
+}).annotate({ "identifier": "ApiKey" });
+Struct({
+	"apps": optionalKey(ApiKeyApps),
+	"expiresAt": String$1.annotate({ "description": "When the key stops getting tokens. Required: every key expires (Decision 11A)." }),
+	"name": String$1.annotate({ "description": "A name for people to read, 1 to 100 characters." }).check(isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })).check(isMaxCodePoints(100).annotate({ "expected": "a string with at most 100 code points" })),
+	"scopes": TupleWithRest(Tuple([ApiKeyScope]), [ApiKeyScope]).annotate({ "description": "What the key may do: one or more scopes." }),
+	"spendCap": SpendCap_1
+}).annotate({ "identifier": "CreateApiKey" });
+const AppPage = Struct({
+	"items": ArraySchema(App),
+	"nextCursor": optionalKey(String$1.annotate({ "description": "Pass as cursor for the next page." }))
+}).annotate({ "identifier": "AppPage" });
+Struct({
+	"from": optionalKey(EnvironmentOrigin_1),
+	"name": EnvironmentName
+}).annotate({ "identifier": "CreateEnvironment" });
+const Environment = Struct({
+	"createdAt": String$1,
+	"from": optionalKey(EnvironmentOrigin),
+	"hostname": optionalKey(AppHostname),
+	"name": EnvironmentName,
+	"promotion": optionalKey(Promotion),
+	"quiet": optionalKey(Boolean.annotate({ "description": "True while its timers, outbox and jobs are held, not dropped: a branch until it is promoted, and an environment a promote fenced. Calls are still served." })),
+	"readOnly": optionalKey(Boolean.annotate({ "description": "True once a promote moved its hostname to another environment: its store takes no writes and no builds, and keeps its data until deleted. Deploys to it go to the environment now serving its hostname, or are refused once none does. Promote it to move the hostname back." })),
+	"reason": optionalKey(String$1.annotate({ "description": "Why a Failed branch was not made." })),
+	"status": EnvironmentStatus,
+	"storage": optionalKey(String$1.annotate({ "description": "Set on a branch: it lives on the disk of the environment it came from, which Archil measures once with its branches, so its storage is billed with that disk. A deleted branch's data stays on that disk, counting against the store's ceilings, until the disk is deleted." }))
+}).annotate({
+	"description": "One environment of an app, such as prod or pr-42, with its own store. Its store's disk counts against the store's ceilings and is metered as storage until the environment is deleted; a deleted environment's kept data is not billed, except a branch's, which is billed with its source's disk (see storage).",
+	"identifier": "Environment"
+});
+const SnapshotPage = Struct({
+	"items": ArraySchema(Snapshot),
+	"nextCursor": optionalKey(String$1.annotate({ "description": "Pass as cursor for the next page." }))
+}).annotate({ "identifier": "SnapshotPage" });
+const BuildActor = Struct({
+	"contract": Sha256_1,
+	"migrations": ArraySchema(BuildMigration),
+	"name": String$1.check(isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })),
+	"staleForMs": optionalKey(Record(String$1, Number$1.annotate({ "description": "How old an answer to the query may be, in milliseconds, when no atLeast asks for newer." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(0).annotate({ "expected": "a value greater than or equal to 0" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" }))).annotate({ "description": "Each query that declares staleFor, by name. A query not listed, or a build without the field, is always fresh." }).check(isPropertyNames(String$1.check(isMinLength(1).annotate({ "expected": "a value with a length of at least 1" }))).annotate({ "expected": "an object with property names matching the schema" })))
+}).annotate({ "identifier": "BuildActor" });
+const ExportFilePage = Struct({
+	"files": ArraySchema(ExportedFile),
+	"next": optionalKey(Sha256)
+}).annotate({
+	"description": "A page of the files an export snapshot holds, in SHA-256 order. Pass next as after for the following page; a page without next is the last. The snapshot holds each file until it expires, so a file it holds can still be read after the actor changes or removes it.",
+	"identifier": "ExportFilePage"
+});
+const DeployPage = Struct({
+	"items": ArraySchema(Deploy),
+	"nextCursor": optionalKey(String$1.annotate({ "description": "Pass as cursor for the next page." }))
+}).annotate({ "identifier": "DeployPage" });
+const DomainPage = Struct({
+	"items": ArraySchema(Domain),
+	"nextCursor": optionalKey(String$1.annotate({ "description": "Pass as cursor for the next page." }))
+}).annotate({ "identifier": "DomainPage" });
+const LogPage = Struct({
+	"items": ArraySchema(LogLine),
+	"nextCursor": optionalKey(String$1.annotate({ "description": "Pass as cursor for the next page." }))
+}).annotate({ "identifier": "LogPage" });
+const AppSecretList = Struct({ "items": ArraySchema(AppSecret) }).annotate({ "identifier": "AppSecretList" });
+const ActorPage = Struct({
+	"actors": ArraySchema(ExportedActor),
+	"next": optionalKey(ActorCursor)
+}).annotate({
+	"description": "A page of the app's stored actors, by shard and then by actor and key. A page holds limit actors unless it is the last; next is absent exactly on the last page, so read on while next is present. An erased actor is still listed until its storage is reclaimed.",
+	"identifier": "ActorPage"
+});
+const ExportShardPage = Struct({
+	"actors": ArraySchema(ExportedActor),
+	"computers": optionalKey(ArraySchema(ExportedComputer).annotate({ "description": "The computers those actors keep, ordered by actor, key and name. Absent from a host that predates computers." }))
+}).annotate({
+	"description": "Every actor stored on the shard, ordered by actor and key, and the computers they keep.",
+	"identifier": "ExportShardPage"
+});
+const CommandHistoryPage = Struct({
+	"entries": ArraySchema(CommandEntry),
+	"next": optionalKey(CommandSeq)
+}).annotate({
+	"description": "Commands in seq order. When the page is full, next is its last seq: pass it as after for the next page.",
+	"identifier": "CommandHistoryPage"
+});
+const MemberPage = Struct({
+	"items": ArraySchema(Member),
+	"nextCursor": optionalKey(String$1.annotate({ "description": "Pass as cursor for the next page." }))
+}).annotate({ "identifier": "MemberPage" });
+const InvitationPage = Struct({
+	"items": ArraySchema(Invitation),
+	"nextCursor": optionalKey(String$1.annotate({ "description": "Pass as cursor for the next page." }))
+}).annotate({ "identifier": "InvitationPage" });
+const Usage = Struct({
+	"apiKey": optionalKey(ApiKeyId),
+	"app": optionalKey(AppName),
+	"capUsd": Usd,
+	"meters": ArraySchema(MeterUsage),
+	"period": BillingPeriod_1,
+	"spentUsd": Usd_1
+}).annotate({ "identifier": "Usage" });
+const InvoicePage = Struct({
+	"items": ArraySchema(Invoice),
+	"nextCursor": optionalKey(String$1.annotate({ "description": "Pass as cursor for the next page." }))
+}).annotate({ "identifier": "InvoicePage" });
+const SignedIn = Struct({
+	"account": Account,
+	"created": Boolean.annotate({ "description": "true when this code created the account." }),
+	"secret": String$1.annotate({ "description": "The session's bearer secret, as_ and 32 characters. Exchange it at POST /v1/tokens. It is returned once and never again." }),
+	"session": Session
+}).annotate({ "identifier": "SignedIn" });
+const SessionPage = Struct({
+	"items": ArraySchema(Session),
+	"nextCursor": optionalKey(String$1.annotate({ "description": "Pass as cursor for the next page." }))
+}).annotate({ "identifier": "SessionPage" });
+const ApiKeyPage = Struct({
+	"items": ArraySchema(ApiKey),
+	"nextCursor": optionalKey(String$1.annotate({ "description": "Pass as cursor for the next page." }))
+}).annotate({ "identifier": "ApiKeyPage" });
+const CreatedApiKey = Struct({
+	"key": ApiKey,
+	"secret": String$1.annotate({ "description": "The bearer secret. It is returned once and never again." })
+}).annotate({ "identifier": "CreatedApiKey" });
+const EnvironmentPage = Struct({
+	"items": ArraySchema(Environment),
+	"nextCursor": optionalKey(String$1.annotate({ "description": "Pass as cursor for the next page." }))
+}).annotate({ "identifier": "EnvironmentPage" });
+const BuildManifest = Struct({ "actors": ArraySchema(BuildActor) }).annotate({
+	"description": "build.json: the actor types, contract hashes and migrations of a build.",
+	"identifier": "BuildManifest"
+});
+const Build = Struct({
+	"app": AppName,
+	"createdAt": String$1,
+	"digest": Sha256,
+	"id": BuildId,
+	"manifest": BuildManifest,
+	"size": Number$1.annotate({ "description": "The build's size in bytes." }).check(isInt().annotate({ "expected": "an integer" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" })).check(isGreaterThan(0).annotate({ "expected": "a value greater than 0" })),
+	"status": BuildStatus
+}).annotate({ "identifier": "Build" });
+Struct({
+	"digest": Sha256,
+	"manifest": BuildManifest,
+	"size": Number$1.annotate({ "description": "The build's size in bytes." }).check(isInt().annotate({ "expected": "an integer" })).check(isLessThanOrEqualTo(9007199254740991).annotate({ "expected": "a value less than or equal to 9007199254740991" })).check(isGreaterThan(0).annotate({ "expected": "a value greater than 0" }))
+}).annotate({ "identifier": "CreateBuild" });
+const BuildPage = Struct({
+	"items": ArraySchema(Build),
+	"nextCursor": optionalKey(String$1.annotate({ "description": "Pass as cursor for the next page." }))
+}).annotate({ "identifier": "BuildPage" });
+const CreatedBuild = Struct({
+	"build": Build,
+	"upload": optionalKey(BuildUpload)
+}).annotate({ "identifier": "CreatedBuild" });
+Struct({
+	"cursor": optionalKey(String$1.annotate({ "description": "The nextCursor of the previous page." })),
+	"limit": optionalKey(Number$1.annotate({ "description": "At most this many items, 1 to 100. Defaults to 50." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })))
+});
+const OrganizationsList200 = OrganizationPage;
+const OrganizationsList401 = UnauthorizedErrorEncoded;
+const OrganizationsList503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const OrganizationsCreate201 = Organization;
+const OrganizationsCreate401 = UnauthorizedErrorEncoded;
+const OrganizationsCreate409 = AlreadyExistsErrorEncoded;
+const OrganizationsCreate503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const OrganizationsGet200 = Organization;
+const OrganizationsGet401 = UnauthorizedErrorEncoded;
+const OrganizationsGet403 = ForbiddenErrorEncoded;
+const OrganizationsGet404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const OrganizationsGet503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const OrganizationsDelete401 = UnauthorizedErrorEncoded;
+const OrganizationsDelete403 = ForbiddenErrorEncoded;
+const OrganizationsDelete404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const OrganizationsDelete409 = InUseErrorEncoded;
+const OrganizationsDelete428 = ConfirmationRequiredErrorEncoded;
+const OrganizationsDelete503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const OrganizationsUpdate200 = Organization;
+const OrganizationsUpdate401 = UnauthorizedErrorEncoded;
+const OrganizationsUpdate403 = ForbiddenErrorEncoded;
+const OrganizationsUpdate404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const OrganizationsUpdate503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({
+	"cursor": optionalKey(String$1.annotate({ "description": "The nextCursor of the previous page." })),
+	"limit": optionalKey(Number$1.annotate({ "description": "At most this many items, 1 to 100. Defaults to 50." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })))
+});
+const ApiKeysList200 = ApiKeyPage;
+const ApiKeysList401 = UnauthorizedErrorEncoded;
+const ApiKeysList403 = ForbiddenErrorEncoded;
+const ApiKeysList404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const ApiKeysList503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const ApiKeysCreate201 = CreatedApiKey;
+const ApiKeysCreate401 = UnauthorizedErrorEncoded;
+const ApiKeysCreate403 = ForbiddenErrorEncoded;
+const ApiKeysCreate404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const ApiKeysCreate503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const ApiKeysRevoke401 = UnauthorizedErrorEncoded;
+const ApiKeysRevoke403 = ForbiddenErrorEncoded;
+const ApiKeysRevoke404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const ApiKeysRevoke428 = ConfirmationRequiredErrorEncoded;
+const ApiKeysRevoke503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const ApiKeysUpdate200 = ApiKey;
+const ApiKeysUpdate401 = UnauthorizedErrorEncoded;
+const ApiKeysUpdate403 = ForbiddenErrorEncoded;
+const ApiKeysUpdate404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const ApiKeysUpdate428 = ConfirmationRequiredErrorEncoded;
+const ApiKeysUpdate503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const ApprovalsRequest202 = ApprovalRequested;
+const ApprovalsRequest401 = UnauthorizedErrorEncoded;
+const ApprovalsRequest403 = ForbiddenErrorEncoded;
+const ApprovalsRequest404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const ApprovalsRequest429 = RateLimitedErrorEncoded;
+const ApprovalsRequest503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const ApprovalsConfirm201 = ApprovalToken;
+const ApprovalsConfirm401 = Union([CodeRejectedErrorEncoded, UnauthorizedErrorEncoded]);
+const ApprovalsConfirm403 = ForbiddenErrorEncoded;
+const ApprovalsConfirm404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const ApprovalsConfirm503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({
+	"cursor": optionalKey(String$1.annotate({ "description": "The nextCursor of the previous page." })),
+	"limit": optionalKey(Number$1.annotate({ "description": "At most this many items, 1 to 100. Defaults to 50." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })))
+});
+const AppsList200 = AppPage;
+const AppsList401 = UnauthorizedErrorEncoded;
+const AppsList403 = ForbiddenErrorEncoded;
+const AppsList404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const AppsList503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const AppsCreate201 = App;
+const AppsCreate401 = UnauthorizedErrorEncoded;
+const AppsCreate403 = ForbiddenErrorEncoded;
+const AppsCreate404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const AppsCreate409 = AlreadyExistsErrorEncoded;
+const AppsCreate503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const AppsGet200 = App;
+const AppsGet401 = UnauthorizedErrorEncoded;
+const AppsGet403 = ForbiddenErrorEncoded;
+const AppsGet404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const AppsGet503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const AppsDelete401 = UnauthorizedErrorEncoded;
+const AppsDelete403 = ForbiddenErrorEncoded;
+const AppsDelete404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const AppsDelete428 = ConfirmationRequiredErrorEncoded;
+const AppsDelete503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({
+	"cursor": optionalKey(String$1.annotate({ "description": "The nextCursor of the previous page." })),
+	"limit": optionalKey(Number$1.annotate({ "description": "At most this many items, 1 to 100. Defaults to 50." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })))
+});
+const EnvironmentsList200 = EnvironmentPage;
+const EnvironmentsList401 = UnauthorizedErrorEncoded;
+const EnvironmentsList403 = ForbiddenErrorEncoded;
+const EnvironmentsList404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const EnvironmentsList503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const EnvironmentsCreate201 = Environment;
+const EnvironmentsCreate401 = UnauthorizedErrorEncoded;
+const EnvironmentsCreate403 = ForbiddenErrorEncoded;
+const EnvironmentsCreate404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const EnvironmentsCreate409 = Union([AlreadyExistsErrorEncoded, InUseErrorEncoded]);
+const EnvironmentsCreate503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const EnvironmentsGet200 = Environment;
+const EnvironmentsGet401 = UnauthorizedErrorEncoded;
+const EnvironmentsGet403 = ForbiddenErrorEncoded;
+const EnvironmentsGet404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const EnvironmentsGet503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const EnvironmentsDelete202 = Environment;
+const EnvironmentsDelete401 = UnauthorizedErrorEncoded;
+const EnvironmentsDelete403 = ForbiddenErrorEncoded;
+const EnvironmentsDelete404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const EnvironmentsDelete409 = InUseErrorEncoded;
+const EnvironmentsDelete428 = ConfirmationRequiredErrorEncoded;
+const EnvironmentsDelete503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const EnvironmentsPromote202 = Promotion;
+const EnvironmentsPromote401 = UnauthorizedErrorEncoded;
+const EnvironmentsPromote403 = ForbiddenErrorEncoded;
+const EnvironmentsPromote404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const EnvironmentsPromote409 = InUseErrorEncoded;
+const EnvironmentsPromote428 = ConfirmationRequiredErrorEncoded;
+const EnvironmentsPromote503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({
+	"cursor": optionalKey(String$1.annotate({ "description": "The nextCursor of the previous page." })),
+	"limit": optionalKey(Number$1.annotate({ "description": "At most this many items, 1 to 100. Defaults to 50." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })))
+});
+const SnapshotsList200 = SnapshotPage;
+const SnapshotsList401 = UnauthorizedErrorEncoded;
+const SnapshotsList403 = ForbiddenErrorEncoded;
+const SnapshotsList404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const SnapshotsList503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const SnapshotsCreate202 = Snapshot;
+const SnapshotsCreate401 = UnauthorizedErrorEncoded;
+const SnapshotsCreate403 = ForbiddenErrorEncoded;
+const SnapshotsCreate404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const SnapshotsCreate409 = Union([
+	AlreadyExistsErrorEncoded,
+	InUseErrorEncoded,
+	SnapshotLimitErrorEncoded
+]);
+const SnapshotsCreate503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const SnapshotsGet200 = Snapshot;
+const SnapshotsGet401 = UnauthorizedErrorEncoded;
+const SnapshotsGet403 = ForbiddenErrorEncoded;
+const SnapshotsGet404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const SnapshotsGet503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const SnapshotsDelete200 = Snapshot;
+const SnapshotsDelete401 = UnauthorizedErrorEncoded;
+const SnapshotsDelete403 = ForbiddenErrorEncoded;
+const SnapshotsDelete404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const SnapshotsDelete428 = ConfirmationRequiredErrorEncoded;
+const SnapshotsDelete503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({
+	"cursor": optionalKey(String$1.annotate({ "description": "The nextCursor of the previous page." })),
+	"limit": optionalKey(Number$1.annotate({ "description": "At most this many items, 1 to 100. Defaults to 50." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })))
+});
+const BuildsList200 = BuildPage;
+const BuildsList401 = UnauthorizedErrorEncoded;
+const BuildsList403 = ForbiddenErrorEncoded;
+const BuildsList404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const BuildsList503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const BuildsCreate201 = CreatedBuild;
+const BuildsCreate401 = UnauthorizedErrorEncoded;
+const BuildsCreate403 = ForbiddenErrorEncoded;
+const BuildsCreate404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const BuildsCreate503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const BuildsGet200 = Build;
+const BuildsGet401 = UnauthorizedErrorEncoded;
+const BuildsGet403 = ForbiddenErrorEncoded;
+const BuildsGet404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const BuildsGet503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({
+	"cursor": optionalKey(String$1.annotate({ "description": "The nextCursor of the previous page." })),
+	"limit": optionalKey(Number$1.annotate({ "description": "At most this many items, 1 to 100. Defaults to 50." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })))
+});
+const DeploysList200 = DeployPage;
+const DeploysList401 = UnauthorizedErrorEncoded;
+const DeploysList403 = ForbiddenErrorEncoded;
+const DeploysList404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const DeploysList503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const DeploysCreate202 = Deploy;
+const DeploysCreate401 = UnauthorizedErrorEncoded;
+const DeploysCreate403 = ForbiddenErrorEncoded;
+const DeploysCreate404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const DeploysCreate409 = Union([
+	DeployInFlightErrorEncoded,
+	BuildNotReadyErrorEncoded,
+	MigrationEditedErrorEncoded,
+	InUseErrorEncoded
+]);
+const DeploysCreate503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const DeploysGet200 = Deploy;
+const DeploysGet401 = UnauthorizedErrorEncoded;
+const DeploysGet403 = ForbiddenErrorEncoded;
+const DeploysGet404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const DeploysGet503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({
+	"cursor": optionalKey(String$1.annotate({ "description": "The nextCursor of the previous page." })),
+	"limit": optionalKey(Number$1.annotate({ "description": "At most this many items, 1 to 100. Defaults to 50." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })))
+});
+const DomainsList200 = DomainPage;
+const DomainsList401 = UnauthorizedErrorEncoded;
+const DomainsList403 = ForbiddenErrorEncoded;
+const DomainsList404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const DomainsList503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const DomainsCreate202 = Domain;
+const DomainsCreate401 = UnauthorizedErrorEncoded;
+const DomainsCreate403 = ForbiddenErrorEncoded;
+const DomainsCreate404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const DomainsCreate409 = HostnameClaimedErrorEncoded;
+const DomainsCreate503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const DomainsGet200 = Domain;
+const DomainsGet401 = UnauthorizedErrorEncoded;
+const DomainsGet403 = ForbiddenErrorEncoded;
+const DomainsGet404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const DomainsGet503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const DomainsDelete401 = UnauthorizedErrorEncoded;
+const DomainsDelete403 = ForbiddenErrorEncoded;
+const DomainsDelete404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const DomainsDelete428 = ConfirmationRequiredErrorEncoded;
+const DomainsDelete503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const LogsReadParams = Struct({
+	"cursor": optionalKey(String$1.annotate({ "description": "The nextCursor of the previous page." })),
+	"limit": optionalKey(String$1.annotate({ "description": "At most this many items, 1 to 100. Defaults to 50." })),
+	"deploy": optionalKey(DeployId_1),
+	"since": optionalKey(String$1.annotate({ "description": "Only the lines written at or after this time." })),
+	"source": optionalKey(LogSource)
+});
+const LogsRead200 = LogPage;
+const LogsRead401 = UnauthorizedErrorEncoded;
+const LogsRead403 = ForbiddenErrorEncoded;
+const LogsRead404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const LogsRead503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const SecretsSet200 = AppSecret;
+const SecretsSet401 = UnauthorizedErrorEncoded;
+const SecretsSet403 = ForbiddenErrorEncoded;
+const SecretsSet404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const SecretsSet503 = Union([
+	SecretsUnavailableErrorEncoded,
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const SecretsDelete401 = UnauthorizedErrorEncoded;
+const SecretsDelete403 = ForbiddenErrorEncoded;
+const SecretsDelete404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const SecretsDelete428 = ConfirmationRequiredErrorEncoded;
+const SecretsDelete503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const SecretsList200 = AppSecretList;
+const SecretsList401 = UnauthorizedErrorEncoded;
+const SecretsList403 = ForbiddenErrorEncoded;
+const SecretsList404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const SecretsList503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({
+	"actor": optionalKey(ActorFilter),
+	"after": optionalKey(ActorCursor),
+	"environment": optionalKey(ActorEnvironment),
+	"limit": optionalKey(Number$1.annotate({ "description": "At most this many actors, 1 to 500. Defaults to 500." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(500).annotate({ "expected": "a value less than or equal to 500" })))
+});
+const ActorsList200 = ActorPage;
+const ActorsList401 = UnauthorizedErrorEncoded;
+const ActorsList403 = ForbiddenErrorEncoded;
+const ActorsList404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const ActorsList503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({
+	"after": optionalKey(Number$1.annotate({ "description": "Only commands after this seq. Pass the previous page's next. Defaults to 0, the start." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(0).annotate({ "expected": "a value greater than or equal to 0" }))),
+	"limit": optionalKey(Number$1.annotate({ "description": "At most this many commands, 1 to 500. Defaults to 500." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(500).annotate({ "expected": "a value less than or equal to 500" }))),
+	"since": optionalKey(String$1.annotate({ "description": "Only commands recorded at or after this time." }))
+});
+const ActorsHistory200 = CommandHistoryPage;
+const ActorsHistory401 = UnauthorizedErrorEncoded;
+const ActorsHistory403 = ForbiddenErrorEncoded;
+const ActorsHistory404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const ActorsHistory410 = ActorErasedErrorEncoded;
+const ActorsHistory503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const ActorsErase401 = UnauthorizedErrorEncoded;
+const ActorsErase403 = ForbiddenErrorEncoded;
+const ActorsErase404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const ActorsErase428 = ConfirmationRequiredErrorEncoded;
+const ActorsErase503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const ActorsExportShard200 = ExportShardPage;
+const ActorsExportShard401 = UnauthorizedErrorEncoded;
+const ActorsExportShard403 = ForbiddenErrorEncoded;
+const ActorsExportShard404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const ActorsExportShard503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const ActorsExportSnapshot201 = ExportSnapshot;
+const ActorsExportSnapshot401 = UnauthorizedErrorEncoded;
+const ActorsExportSnapshot403 = ForbiddenErrorEncoded;
+const ActorsExportSnapshot404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const ActorsExportSnapshot410 = Union([ActorErasedErrorEncoded, ExportSnapshotGoneErrorEncoded]);
+const ActorsExportSnapshot503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({
+	"actor": ActorType,
+	"key": ExportKey,
+	"length": Number$1.annotate({ "description": "How many bytes to read, 1 to 65536." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(65536).annotate({ "expected": "a value less than or equal to 65536" })),
+	"offset": Number$1.annotate({ "description": "The first byte to read." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(0).annotate({ "expected": "a value greater than or equal to 0" }))
+});
+const ActorsExportRead401 = UnauthorizedErrorEncoded;
+const ActorsExportRead403 = ForbiddenErrorEncoded;
+const ActorsExportRead404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const ActorsExportRead410 = Union([ActorErasedErrorEncoded, ExportSnapshotGoneErrorEncoded]);
+const ActorsExportRead503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({
+	"actor": ActorType,
+	"after": optionalKey(Sha256),
+	"key": ExportKey
+});
+const ActorsExportFiles200 = ExportFilePage;
+const ActorsExportFiles401 = UnauthorizedErrorEncoded;
+const ActorsExportFiles403 = ForbiddenErrorEncoded;
+const ActorsExportFiles404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const ActorsExportFiles410 = Union([ActorErasedErrorEncoded, ExportSnapshotGoneErrorEncoded]);
+const ActorsExportFiles503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({
+	"actor": ActorType,
+	"key": ExportKey,
+	"length": Number$1.annotate({ "description": "How many bytes to read, 1 to 65536." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(65536).annotate({ "expected": "a value less than or equal to 65536" })),
+	"offset": Number$1.annotate({ "description": "The first byte to read." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(0).annotate({ "expected": "a value greater than or equal to 0" }))
+});
+const ActorsExportFileRead401 = UnauthorizedErrorEncoded;
+const ActorsExportFileRead403 = ForbiddenErrorEncoded;
+const ActorsExportFileRead404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const ActorsExportFileRead410 = Union([ActorErasedErrorEncoded, ExportSnapshotGoneErrorEncoded]);
+const ActorsExportFileRead503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({ "environment": optionalKey(ExecEnvironment) });
+const ActorsExec200 = ExecResult;
+const ActorsExec401 = UnauthorizedErrorEncoded;
+const ActorsExec403 = ForbiddenErrorEncoded;
+const ActorsExec404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const ActorsExec409 = ExecRefusedErrorEncoded;
+const ActorsExec410 = ActorErasedErrorEncoded;
+const ActorsExec503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const ActorForksCreate201 = ActorFork;
+const ActorForksCreate401 = UnauthorizedErrorEncoded;
+const ActorForksCreate403 = ForbiddenErrorEncoded;
+const ActorForksCreate404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const ActorForksCreate409 = AlreadyExistsErrorEncoded;
+const ActorForksCreate410 = ActorErasedErrorEncoded;
+const ActorForksCreate428 = ConfirmationRequiredErrorEncoded;
+const ActorForksCreate503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({
+	"cursor": optionalKey(String$1.annotate({ "description": "The nextCursor of the previous page." })),
+	"limit": optionalKey(Number$1.annotate({ "description": "At most this many items, 1 to 100. Defaults to 50." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })))
+});
+const MembersList200 = MemberPage;
+const MembersList401 = UnauthorizedErrorEncoded;
+const MembersList403 = ForbiddenErrorEncoded;
+const MembersList404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const MembersList503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const MembersAdd201 = Member;
+const MembersAdd401 = UnauthorizedErrorEncoded;
+const MembersAdd403 = ForbiddenErrorEncoded;
+const MembersAdd404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const MembersAdd409 = AlreadyExistsErrorEncoded;
+const MembersAdd503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const MembersRemove401 = UnauthorizedErrorEncoded;
+const MembersRemove403 = ForbiddenErrorEncoded;
+const MembersRemove404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const MembersRemove428 = ConfirmationRequiredErrorEncoded;
+const MembersRemove503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const MembersChangeRole200 = Member;
+const MembersChangeRole401 = UnauthorizedErrorEncoded;
+const MembersChangeRole403 = ForbiddenErrorEncoded;
+const MembersChangeRole404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const MembersChangeRole503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({
+	"cursor": optionalKey(String$1.annotate({ "description": "The nextCursor of the previous page." })),
+	"limit": optionalKey(Number$1.annotate({ "description": "At most this many items, 1 to 100. Defaults to 50." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })))
+});
+const InvitationsList200 = InvitationPage;
+const InvitationsList401 = UnauthorizedErrorEncoded;
+const InvitationsList403 = ForbiddenErrorEncoded;
+const InvitationsList404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const InvitationsList503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const InvitationsCreate201 = Invitation;
+const InvitationsCreate401 = UnauthorizedErrorEncoded;
+const InvitationsCreate403 = ForbiddenErrorEncoded;
+const InvitationsCreate404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const InvitationsCreate409 = AlreadyExistsErrorEncoded;
+const InvitationsCreate503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const InvitationsRevoke401 = UnauthorizedErrorEncoded;
+const InvitationsRevoke403 = ForbiddenErrorEncoded;
+const InvitationsRevoke404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const InvitationsRevoke503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const InvitationsAccept201 = Member;
+const InvitationsAccept401 = UnauthorizedErrorEncoded;
+const InvitationsAccept403 = ForbiddenErrorEncoded;
+const InvitationsAccept404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const InvitationsAccept409 = AlreadyExistsErrorEncoded;
+const InvitationsAccept503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({
+	"app": optionalKey(AppName_1),
+	"key": optionalKey(ApiKeyId_1),
+	"period": optionalKey(BillingPeriod)
+});
+const UsageGet200 = Usage;
+const UsageGet401 = UnauthorizedErrorEncoded;
+const UsageGet403 = ForbiddenErrorEncoded;
+const UsageGet404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const UsageGet503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const UsageForecast200 = UsageForecast;
+const UsageForecast401 = UnauthorizedErrorEncoded;
+const UsageForecast403 = ForbiddenErrorEncoded;
+const UsageForecast404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const UsageForecast503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const BillingGet200 = BillingAccount;
+const BillingGet401 = UnauthorizedErrorEncoded;
+const BillingGet403 = ForbiddenErrorEncoded;
+const BillingGet404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const BillingGet503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const BillingCancel200 = BillingAccount;
+const BillingCancel401 = UnauthorizedErrorEncoded;
+const BillingCancel403 = ForbiddenErrorEncoded;
+const BillingCancel404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const BillingCancel428 = ConfirmationRequiredErrorEncoded;
+const BillingCancel503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const BillingCheckout201 = CheckoutLink;
+const BillingCheckout401 = UnauthorizedErrorEncoded;
+const BillingCheckout403 = ForbiddenErrorEncoded;
+const BillingCheckout404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const BillingCheckout503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const BillingSetCap200 = BillingAccount;
+const BillingSetCap401 = UnauthorizedErrorEncoded;
+const BillingSetCap402 = CardRequiredErrorEncoded;
+const BillingSetCap403 = ForbiddenErrorEncoded;
+const BillingSetCap404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const BillingSetCap428 = ConfirmationRequiredErrorEncoded;
+const BillingSetCap503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+Struct({
+	"cursor": optionalKey(String$1.annotate({ "description": "The nextCursor of the previous page." })),
+	"limit": optionalKey(Number$1.annotate({ "description": "At most this many items, 1 to 100. Defaults to 50." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })))
+});
+const BillingInvoices200 = InvoicePage;
+const BillingInvoices401 = UnauthorizedErrorEncoded;
+const BillingInvoices403 = ForbiddenErrorEncoded;
+const BillingInvoices404 = Union([NotFoundErrorEncoded, FeatureNotEnabledErrorEncoded]);
+const BillingInvoices503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const TokensExchange200 = IssuedToken;
+const TokensExchange401 = UnauthorizedErrorEncoded;
+const TokensExchange503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const SignInSendCode202 = CodeSent;
+const SignInSendCode429 = RateLimitedErrorEncoded;
+const SignInVerifyCode201 = SignedIn;
+const SignInVerifyCode401 = CodeRejectedErrorEncoded;
+const SignInVerifyCode422 = TermsNotAcceptedErrorEncoded;
+const SignInVerifyCode429 = RateLimitedErrorEncoded;
+Struct({
+	"cursor": optionalKey(String$1.annotate({ "description": "The nextCursor of the previous page." })),
+	"limit": optionalKey(Number$1.annotate({ "description": "At most this many items, 1 to 100. Defaults to 50." }).check(isInt().annotate({ "expected": "an integer" })).check(isGreaterThanOrEqualTo(1).annotate({ "expected": "a value greater than or equal to 1" })).check(isLessThanOrEqualTo(100).annotate({ "expected": "a value less than or equal to 100" })))
+});
+const SessionsList200 = SessionPage;
+const SessionsList401 = UnauthorizedErrorEncoded;
+const SessionsList503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const SessionsRevoke401 = UnauthorizedErrorEncoded;
+const SessionsRevoke404 = NotFoundErrorEncoded;
+const SessionsRevoke503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const AccountGet200 = Account;
+const AccountGet401 = UnauthorizedErrorEncoded;
+const AccountGet404 = NotFoundErrorEncoded;
+const AccountGet503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const AccountDelete401 = UnauthorizedErrorEncoded;
+const AccountDelete403 = ForbiddenErrorEncoded;
+const AccountDelete404 = NotFoundErrorEncoded;
+const AccountDelete409 = InUseErrorEncoded;
+const AccountDelete428 = ConfirmationRequiredErrorEncoded;
+const AccountDelete503 = Union([
+	ActorUnavailableErrorEncoded,
+	AuthUnavailableErrorEncoded,
+	BillingUnavailableErrorEncoded,
+	BuildStorageUnavailableErrorEncoded,
+	ExecUnavailableErrorEncoded
+]);
+const make = (httpClient, options = {}) => {
+	const unexpectedStatus = (response) => flatMap(orElseSucceed(response.json, () => "Unexpected status code"), (description) => fail(new HttpClientError({ reason: new StatusCodeError({
+		request: response.request,
+		response,
+		description: typeof description === "string" ? description : JSON.stringify(description)
+	}) })));
+	const withResponse = (config) => (f) => {
+		const withOptionalResponse = config?.includeResponse ? (response) => map(f(response), (a) => [a, response]) : (response) => f(response);
+		return options?.transformClient ? (request) => flatMap(flatMap(options.transformClient(httpClient), (client) => client.execute(request)), withOptionalResponse) : (request) => flatMap(httpClient.execute(request), withOptionalResponse);
+	};
+	const __encodePathParam = encodeURIComponent;
+	const __makePathRequest = (method, parameters, getPath) => suspend(() => {
+		const fail$2 = (description, cause) => fail(new HttpClientError({ reason: new InvalidUrlError({
+			request: method(""),
+			cause,
+			description
+		}) }));
+		if (parameters.some((value) => value === "" || /^(?:\.|%2e){1,2}$/i.test(value))) return fail$2("Path parameters must be non-empty and cannot be dot segments");
+		let path;
+		try {
+			path = getPath();
+		} catch (cause) {
+			return fail$2("Failed to encode path parameter", cause);
+		}
+		if (path.split("/").some((segment) => /^(?:\.|%2e){1,2}$/i.test(segment))) return fail$2("Request paths cannot contain dot segments");
+		return succeed(method(path));
+	});
+	const executeStreamRequest = (request) => suspend(() => options.transformClient ? flatMap(options.transformClient(httpClient), (client) => filterStatusOk(client).execute(request)) : filterStatusOk(httpClient).execute(request));
+	const decodeBinary = (response) => map(response.arrayBuffer, (buffer) => new Uint8Array(buffer));
+	const binaryRequest = (request) => executeStreamRequest(request).pipe(map((response) => response.stream), unwrap);
+	const decodeSuccess = (schema) => (response) => schemaBodyJson(schema)(response);
+	const decodeError = (tag, schema) => (response) => flatMap(schemaBodyJson(schema)(response), (cause) => fail(CloudClientError(tag, cause, response)));
+	return {
+		httpClient,
+		"organizationsList": (options) => get("/v1/organizations").pipe(setUrlParams({
+			"cursor": options?.params?.["cursor"],
+			"limit": options?.params?.["limit"]
+		}), withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(OrganizationsList200),
+			"401": decodeError("OrganizationsList401", OrganizationsList401),
+			"503": decodeError("OrganizationsList503", OrganizationsList503),
+			orElse: unexpectedStatus
+		}))),
+		"organizationsCreate": (options) => post("/v1/organizations").pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(OrganizationsCreate201),
+			"401": decodeError("OrganizationsCreate401", OrganizationsCreate401),
+			"409": decodeError("OrganizationsCreate409", OrganizationsCreate409),
+			"503": decodeError("OrganizationsCreate503", OrganizationsCreate503),
+			orElse: unexpectedStatus
+		}))),
+		"organizationsGet": (organization, options) => __makePathRequest(get, [organization], () => "/v1/organizations/" + __encodePathParam(organization)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(OrganizationsGet200),
+			"401": decodeError("OrganizationsGet401", OrganizationsGet401),
+			"403": decodeError("OrganizationsGet403", OrganizationsGet403),
+			"404": decodeError("OrganizationsGet404", OrganizationsGet404),
+			"503": decodeError("OrganizationsGet503", OrganizationsGet503),
+			orElse: unexpectedStatus
+		}))))),
+		"organizationsDelete": (organization, options) => __makePathRequest(del, [organization], () => "/v1/organizations/" + __encodePathParam(organization)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"401": decodeError("OrganizationsDelete401", OrganizationsDelete401),
+			"403": decodeError("OrganizationsDelete403", OrganizationsDelete403),
+			"404": decodeError("OrganizationsDelete404", OrganizationsDelete404),
+			"409": decodeError("OrganizationsDelete409", OrganizationsDelete409),
+			"428": decodeError("OrganizationsDelete428", OrganizationsDelete428),
+			"503": decodeError("OrganizationsDelete503", OrganizationsDelete503),
+			"204": () => void_,
+			orElse: unexpectedStatus
+		}))))),
+		"organizationsUpdate": (organization, options) => __makePathRequest(patch, [organization], () => "/v1/organizations/" + __encodePathParam(organization)).pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(OrganizationsUpdate200),
+			"401": decodeError("OrganizationsUpdate401", OrganizationsUpdate401),
+			"403": decodeError("OrganizationsUpdate403", OrganizationsUpdate403),
+			"404": decodeError("OrganizationsUpdate404", OrganizationsUpdate404),
+			"503": decodeError("OrganizationsUpdate503", OrganizationsUpdate503),
+			orElse: unexpectedStatus
+		}))))),
+		"apiKeysList": (organization, options) => __makePathRequest(get, [organization], () => "/v1/organizations/" + __encodePathParam(organization) + "/api-keys").pipe(flatMap((request) => request.pipe(setUrlParams({
+			"cursor": options?.params?.["cursor"],
+			"limit": options?.params?.["limit"]
+		}), withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(ApiKeysList200),
+			"401": decodeError("ApiKeysList401", ApiKeysList401),
+			"403": decodeError("ApiKeysList403", ApiKeysList403),
+			"404": decodeError("ApiKeysList404", ApiKeysList404),
+			"503": decodeError("ApiKeysList503", ApiKeysList503),
+			orElse: unexpectedStatus
+		}))))),
+		"apiKeysCreate": (organization, options) => __makePathRequest(post, [organization], () => "/v1/organizations/" + __encodePathParam(organization) + "/api-keys").pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(ApiKeysCreate201),
+			"401": decodeError("ApiKeysCreate401", ApiKeysCreate401),
+			"403": decodeError("ApiKeysCreate403", ApiKeysCreate403),
+			"404": decodeError("ApiKeysCreate404", ApiKeysCreate404),
+			"503": decodeError("ApiKeysCreate503", ApiKeysCreate503),
+			orElse: unexpectedStatus
+		}))))),
+		"apiKeysRevoke": (organization, key, options) => __makePathRequest(del, [organization, key], () => "/v1/organizations/" + __encodePathParam(organization) + "/api-keys/" + __encodePathParam(key)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"401": decodeError("ApiKeysRevoke401", ApiKeysRevoke401),
+			"403": decodeError("ApiKeysRevoke403", ApiKeysRevoke403),
+			"404": decodeError("ApiKeysRevoke404", ApiKeysRevoke404),
+			"428": decodeError("ApiKeysRevoke428", ApiKeysRevoke428),
+			"503": decodeError("ApiKeysRevoke503", ApiKeysRevoke503),
+			"204": () => void_,
+			orElse: unexpectedStatus
+		}))))),
+		"apiKeysUpdate": (organization, key, options) => __makePathRequest(patch, [organization, key], () => "/v1/organizations/" + __encodePathParam(organization) + "/api-keys/" + __encodePathParam(key)).pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(ApiKeysUpdate200),
+			"401": decodeError("ApiKeysUpdate401", ApiKeysUpdate401),
+			"403": decodeError("ApiKeysUpdate403", ApiKeysUpdate403),
+			"404": decodeError("ApiKeysUpdate404", ApiKeysUpdate404),
+			"428": decodeError("ApiKeysUpdate428", ApiKeysUpdate428),
+			"503": decodeError("ApiKeysUpdate503", ApiKeysUpdate503),
+			orElse: unexpectedStatus
+		}))))),
+		"approvalsRequest": (organization, options) => __makePathRequest(post, [organization], () => "/v1/organizations/" + __encodePathParam(organization) + "/approvals").pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(ApprovalsRequest202),
+			"401": decodeError("ApprovalsRequest401", ApprovalsRequest401),
+			"403": decodeError("ApprovalsRequest403", ApprovalsRequest403),
+			"404": decodeError("ApprovalsRequest404", ApprovalsRequest404),
+			"429": decodeError("ApprovalsRequest429", ApprovalsRequest429),
+			"503": decodeError("ApprovalsRequest503", ApprovalsRequest503),
+			orElse: unexpectedStatus
+		}))))),
+		"approvalsConfirm": (organization, request, options) => __makePathRequest(post, [organization, request], () => "/v1/organizations/" + __encodePathParam(organization) + "/approvals/" + __encodePathParam(request) + "/tokens").pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(ApprovalsConfirm201),
+			"401": decodeError("ApprovalsConfirm401", ApprovalsConfirm401),
+			"403": decodeError("ApprovalsConfirm403", ApprovalsConfirm403),
+			"404": decodeError("ApprovalsConfirm404", ApprovalsConfirm404),
+			"503": decodeError("ApprovalsConfirm503", ApprovalsConfirm503),
+			orElse: unexpectedStatus
+		}))))),
+		"appsList": (organization, options) => __makePathRequest(get, [organization], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps").pipe(flatMap((request) => request.pipe(setUrlParams({
+			"cursor": options?.params?.["cursor"],
+			"limit": options?.params?.["limit"]
+		}), withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(AppsList200),
+			"401": decodeError("AppsList401", AppsList401),
+			"403": decodeError("AppsList403", AppsList403),
+			"404": decodeError("AppsList404", AppsList404),
+			"503": decodeError("AppsList503", AppsList503),
+			orElse: unexpectedStatus
+		}))))),
+		"appsCreate": (organization, options) => __makePathRequest(post, [organization], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps").pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(AppsCreate201),
+			"401": decodeError("AppsCreate401", AppsCreate401),
+			"403": decodeError("AppsCreate403", AppsCreate403),
+			"404": decodeError("AppsCreate404", AppsCreate404),
+			"409": decodeError("AppsCreate409", AppsCreate409),
+			"503": decodeError("AppsCreate503", AppsCreate503),
+			orElse: unexpectedStatus
+		}))))),
+		"appsGet": (organization, app, options) => __makePathRequest(get, [organization, app], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(AppsGet200),
+			"401": decodeError("AppsGet401", AppsGet401),
+			"403": decodeError("AppsGet403", AppsGet403),
+			"404": decodeError("AppsGet404", AppsGet404),
+			"503": decodeError("AppsGet503", AppsGet503),
+			orElse: unexpectedStatus
+		}))))),
+		"appsDelete": (organization, app, options) => __makePathRequest(del, [organization, app], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"401": decodeError("AppsDelete401", AppsDelete401),
+			"403": decodeError("AppsDelete403", AppsDelete403),
+			"404": decodeError("AppsDelete404", AppsDelete404),
+			"428": decodeError("AppsDelete428", AppsDelete428),
+			"503": decodeError("AppsDelete503", AppsDelete503),
+			"204": () => void_,
+			orElse: unexpectedStatus
+		}))))),
+		"environmentsList": (organization, app, options) => __makePathRequest(get, [organization, app], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/environments").pipe(flatMap((request) => request.pipe(setUrlParams({
+			"cursor": options?.params?.["cursor"],
+			"limit": options?.params?.["limit"]
+		}), withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(EnvironmentsList200),
+			"401": decodeError("EnvironmentsList401", EnvironmentsList401),
+			"403": decodeError("EnvironmentsList403", EnvironmentsList403),
+			"404": decodeError("EnvironmentsList404", EnvironmentsList404),
+			"503": decodeError("EnvironmentsList503", EnvironmentsList503),
+			orElse: unexpectedStatus
+		}))))),
+		"environmentsCreate": (organization, app, options) => __makePathRequest(post, [organization, app], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/environments").pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(EnvironmentsCreate201),
+			"401": decodeError("EnvironmentsCreate401", EnvironmentsCreate401),
+			"403": decodeError("EnvironmentsCreate403", EnvironmentsCreate403),
+			"404": decodeError("EnvironmentsCreate404", EnvironmentsCreate404),
+			"409": decodeError("EnvironmentsCreate409", EnvironmentsCreate409),
+			"503": decodeError("EnvironmentsCreate503", EnvironmentsCreate503),
+			orElse: unexpectedStatus
+		}))))),
+		"environmentsGet": (organization, app, environment, options) => __makePathRequest(get, [
+			organization,
+			app,
+			environment
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/environments/" + __encodePathParam(environment)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(EnvironmentsGet200),
+			"401": decodeError("EnvironmentsGet401", EnvironmentsGet401),
+			"403": decodeError("EnvironmentsGet403", EnvironmentsGet403),
+			"404": decodeError("EnvironmentsGet404", EnvironmentsGet404),
+			"503": decodeError("EnvironmentsGet503", EnvironmentsGet503),
+			orElse: unexpectedStatus
+		}))))),
+		"environmentsDelete": (organization, app, environment, options) => __makePathRequest(del, [
+			organization,
+			app,
+			environment
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/environments/" + __encodePathParam(environment)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(EnvironmentsDelete202),
+			"401": decodeError("EnvironmentsDelete401", EnvironmentsDelete401),
+			"403": decodeError("EnvironmentsDelete403", EnvironmentsDelete403),
+			"404": decodeError("EnvironmentsDelete404", EnvironmentsDelete404),
+			"409": decodeError("EnvironmentsDelete409", EnvironmentsDelete409),
+			"428": decodeError("EnvironmentsDelete428", EnvironmentsDelete428),
+			"503": decodeError("EnvironmentsDelete503", EnvironmentsDelete503),
+			orElse: unexpectedStatus
+		}))))),
+		"environmentsPromote": (organization, app, environment, options) => __makePathRequest(post, [
+			organization,
+			app,
+			environment
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/environments/" + __encodePathParam(environment) + "/promote").pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(EnvironmentsPromote202),
+			"401": decodeError("EnvironmentsPromote401", EnvironmentsPromote401),
+			"403": decodeError("EnvironmentsPromote403", EnvironmentsPromote403),
+			"404": decodeError("EnvironmentsPromote404", EnvironmentsPromote404),
+			"409": decodeError("EnvironmentsPromote409", EnvironmentsPromote409),
+			"428": decodeError("EnvironmentsPromote428", EnvironmentsPromote428),
+			"503": decodeError("EnvironmentsPromote503", EnvironmentsPromote503),
+			orElse: unexpectedStatus
+		}))))),
+		"snapshotsList": (organization, app, environment, options) => __makePathRequest(get, [
+			organization,
+			app,
+			environment
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/environments/" + __encodePathParam(environment) + "/snapshots").pipe(flatMap((request) => request.pipe(setUrlParams({
+			"cursor": options?.params?.["cursor"],
+			"limit": options?.params?.["limit"]
+		}), withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(SnapshotsList200),
+			"401": decodeError("SnapshotsList401", SnapshotsList401),
+			"403": decodeError("SnapshotsList403", SnapshotsList403),
+			"404": decodeError("SnapshotsList404", SnapshotsList404),
+			"503": decodeError("SnapshotsList503", SnapshotsList503),
+			orElse: unexpectedStatus
+		}))))),
+		"snapshotsCreate": (organization, app, environment, options) => __makePathRequest(post, [
+			organization,
+			app,
+			environment
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/environments/" + __encodePathParam(environment) + "/snapshots").pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(SnapshotsCreate202),
+			"401": decodeError("SnapshotsCreate401", SnapshotsCreate401),
+			"403": decodeError("SnapshotsCreate403", SnapshotsCreate403),
+			"404": decodeError("SnapshotsCreate404", SnapshotsCreate404),
+			"409": decodeError("SnapshotsCreate409", SnapshotsCreate409),
+			"503": decodeError("SnapshotsCreate503", SnapshotsCreate503),
+			orElse: unexpectedStatus
+		}))))),
+		"snapshotsGet": (organization, app, environment, snapshot, options) => __makePathRequest(get, [
+			organization,
+			app,
+			environment,
+			snapshot
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/environments/" + __encodePathParam(environment) + "/snapshots/" + __encodePathParam(snapshot)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(SnapshotsGet200),
+			"401": decodeError("SnapshotsGet401", SnapshotsGet401),
+			"403": decodeError("SnapshotsGet403", SnapshotsGet403),
+			"404": decodeError("SnapshotsGet404", SnapshotsGet404),
+			"503": decodeError("SnapshotsGet503", SnapshotsGet503),
+			orElse: unexpectedStatus
+		}))))),
+		"snapshotsDelete": (organization, app, environment, snapshot, options) => __makePathRequest(del, [
+			organization,
+			app,
+			environment,
+			snapshot
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/environments/" + __encodePathParam(environment) + "/snapshots/" + __encodePathParam(snapshot)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(SnapshotsDelete200),
+			"401": decodeError("SnapshotsDelete401", SnapshotsDelete401),
+			"403": decodeError("SnapshotsDelete403", SnapshotsDelete403),
+			"404": decodeError("SnapshotsDelete404", SnapshotsDelete404),
+			"428": decodeError("SnapshotsDelete428", SnapshotsDelete428),
+			"503": decodeError("SnapshotsDelete503", SnapshotsDelete503),
+			orElse: unexpectedStatus
+		}))))),
+		"buildsList": (organization, app, options) => __makePathRequest(get, [organization, app], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/builds").pipe(flatMap((request) => request.pipe(setUrlParams({
+			"cursor": options?.params?.["cursor"],
+			"limit": options?.params?.["limit"]
+		}), withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(BuildsList200),
+			"401": decodeError("BuildsList401", BuildsList401),
+			"403": decodeError("BuildsList403", BuildsList403),
+			"404": decodeError("BuildsList404", BuildsList404),
+			"503": decodeError("BuildsList503", BuildsList503),
+			orElse: unexpectedStatus
+		}))))),
+		"buildsCreate": (organization, app, options) => __makePathRequest(post, [organization, app], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/builds").pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(BuildsCreate201),
+			"401": decodeError("BuildsCreate401", BuildsCreate401),
+			"403": decodeError("BuildsCreate403", BuildsCreate403),
+			"404": decodeError("BuildsCreate404", BuildsCreate404),
+			"503": decodeError("BuildsCreate503", BuildsCreate503),
+			orElse: unexpectedStatus
+		}))))),
+		"buildsGet": (organization, app, build, options) => __makePathRequest(get, [
+			organization,
+			app,
+			build
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/builds/" + __encodePathParam(build)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(BuildsGet200),
+			"401": decodeError("BuildsGet401", BuildsGet401),
+			"403": decodeError("BuildsGet403", BuildsGet403),
+			"404": decodeError("BuildsGet404", BuildsGet404),
+			"503": decodeError("BuildsGet503", BuildsGet503),
+			orElse: unexpectedStatus
+		}))))),
+		"deploysList": (organization, app, options) => __makePathRequest(get, [organization, app], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/deploys").pipe(flatMap((request) => request.pipe(setUrlParams({
+			"cursor": options?.params?.["cursor"],
+			"limit": options?.params?.["limit"]
+		}), withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(DeploysList200),
+			"401": decodeError("DeploysList401", DeploysList401),
+			"403": decodeError("DeploysList403", DeploysList403),
+			"404": decodeError("DeploysList404", DeploysList404),
+			"503": decodeError("DeploysList503", DeploysList503),
+			orElse: unexpectedStatus
+		}))))),
+		"deploysCreate": (organization, app, options) => __makePathRequest(post, [organization, app], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/deploys").pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(DeploysCreate202),
+			"401": decodeError("DeploysCreate401", DeploysCreate401),
+			"403": decodeError("DeploysCreate403", DeploysCreate403),
+			"404": decodeError("DeploysCreate404", DeploysCreate404),
+			"409": decodeError("DeploysCreate409", DeploysCreate409),
+			"503": decodeError("DeploysCreate503", DeploysCreate503),
+			orElse: unexpectedStatus
+		}))))),
+		"deploysGet": (organization, app, deploy, options) => __makePathRequest(get, [
+			organization,
+			app,
+			deploy
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/deploys/" + __encodePathParam(deploy)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(DeploysGet200),
+			"401": decodeError("DeploysGet401", DeploysGet401),
+			"403": decodeError("DeploysGet403", DeploysGet403),
+			"404": decodeError("DeploysGet404", DeploysGet404),
+			"503": decodeError("DeploysGet503", DeploysGet503),
+			orElse: unexpectedStatus
+		}))))),
+		"domainsList": (organization, app, options) => __makePathRequest(get, [organization, app], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/domains").pipe(flatMap((request) => request.pipe(setUrlParams({
+			"cursor": options?.params?.["cursor"],
+			"limit": options?.params?.["limit"]
+		}), withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(DomainsList200),
+			"401": decodeError("DomainsList401", DomainsList401),
+			"403": decodeError("DomainsList403", DomainsList403),
+			"404": decodeError("DomainsList404", DomainsList404),
+			"503": decodeError("DomainsList503", DomainsList503),
+			orElse: unexpectedStatus
+		}))))),
+		"domainsCreate": (organization, app, options) => __makePathRequest(post, [organization, app], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/domains").pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(DomainsCreate202),
+			"401": decodeError("DomainsCreate401", DomainsCreate401),
+			"403": decodeError("DomainsCreate403", DomainsCreate403),
+			"404": decodeError("DomainsCreate404", DomainsCreate404),
+			"409": decodeError("DomainsCreate409", DomainsCreate409),
+			"503": decodeError("DomainsCreate503", DomainsCreate503),
+			orElse: unexpectedStatus
+		}))))),
+		"domainsGet": (organization, app, hostname, options) => __makePathRequest(get, [
+			organization,
+			app,
+			hostname
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/domains/" + __encodePathParam(hostname)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(DomainsGet200),
+			"401": decodeError("DomainsGet401", DomainsGet401),
+			"403": decodeError("DomainsGet403", DomainsGet403),
+			"404": decodeError("DomainsGet404", DomainsGet404),
+			"503": decodeError("DomainsGet503", DomainsGet503),
+			orElse: unexpectedStatus
+		}))))),
+		"domainsDelete": (organization, app, hostname, options) => __makePathRequest(del, [
+			organization,
+			app,
+			hostname
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/domains/" + __encodePathParam(hostname)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"401": decodeError("DomainsDelete401", DomainsDelete401),
+			"403": decodeError("DomainsDelete403", DomainsDelete403),
+			"404": decodeError("DomainsDelete404", DomainsDelete404),
+			"428": decodeError("DomainsDelete428", DomainsDelete428),
+			"503": decodeError("DomainsDelete503", DomainsDelete503),
+			"202": () => void_,
+			orElse: unexpectedStatus
+		}))))),
+		"logsRead": (organization, app, options) => __makePathRequest(get, [organization, app], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/logs").pipe(flatMap((request) => request.pipe(setUrlParams({
+			"cursor": options?.params?.["cursor"],
+			"limit": options?.params?.["limit"],
+			"deploy": options?.params?.["deploy"],
+			"since": options?.params?.["since"],
+			"source": options?.params?.["source"]
+		}), withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(LogsRead200),
+			"401": decodeError("LogsRead401", LogsRead401),
+			"403": decodeError("LogsRead403", LogsRead403),
+			"404": decodeError("LogsRead404", LogsRead404),
+			"503": decodeError("LogsRead503", LogsRead503),
+			orElse: unexpectedStatus
+		}))))),
+		"secretsSet": (organization, app, environment, name, options) => __makePathRequest(put, [
+			organization,
+			app,
+			environment,
+			name
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/environments/" + __encodePathParam(environment) + "/secrets/" + __encodePathParam(name)).pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(SecretsSet200),
+			"401": decodeError("SecretsSet401", SecretsSet401),
+			"403": decodeError("SecretsSet403", SecretsSet403),
+			"404": decodeError("SecretsSet404", SecretsSet404),
+			"503": decodeError("SecretsSet503", SecretsSet503),
+			orElse: unexpectedStatus
+		}))))),
+		"secretsDelete": (organization, app, environment, name, options) => __makePathRequest(del, [
+			organization,
+			app,
+			environment,
+			name
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/environments/" + __encodePathParam(environment) + "/secrets/" + __encodePathParam(name)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"401": decodeError("SecretsDelete401", SecretsDelete401),
+			"403": decodeError("SecretsDelete403", SecretsDelete403),
+			"404": decodeError("SecretsDelete404", SecretsDelete404),
+			"428": decodeError("SecretsDelete428", SecretsDelete428),
+			"503": decodeError("SecretsDelete503", SecretsDelete503),
+			"204": () => void_,
+			orElse: unexpectedStatus
+		}))))),
+		"secretsList": (organization, app, environment, options) => __makePathRequest(get, [
+			organization,
+			app,
+			environment
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/environments/" + __encodePathParam(environment) + "/secrets").pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(SecretsList200),
+			"401": decodeError("SecretsList401", SecretsList401),
+			"403": decodeError("SecretsList403", SecretsList403),
+			"404": decodeError("SecretsList404", SecretsList404),
+			"503": decodeError("SecretsList503", SecretsList503),
+			orElse: unexpectedStatus
+		}))))),
+		"actorsList": (organization, app, options) => __makePathRequest(get, [organization, app], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/actors").pipe(flatMap((request) => request.pipe(setUrlParams({
+			"actor": options?.params?.["actor"],
+			"after": options?.params?.["after"],
+			"environment": options?.params?.["environment"],
+			"limit": options?.params?.["limit"]
+		}), withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(ActorsList200),
+			"401": decodeError("ActorsList401", ActorsList401),
+			"403": decodeError("ActorsList403", ActorsList403),
+			"404": decodeError("ActorsList404", ActorsList404),
+			"503": decodeError("ActorsList503", ActorsList503),
+			orElse: unexpectedStatus
+		}))))),
+		"actorsHistory": (organization, app, actor, key, options) => __makePathRequest(get, [
+			organization,
+			app,
+			actor,
+			key
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/actors/" + __encodePathParam(actor) + "/" + __encodePathParam(key) + "/history").pipe(flatMap((request) => request.pipe(setUrlParams({
+			"after": options?.params?.["after"],
+			"limit": options?.params?.["limit"],
+			"since": options?.params?.["since"]
+		}), withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(ActorsHistory200),
+			"401": decodeError("ActorsHistory401", ActorsHistory401),
+			"403": decodeError("ActorsHistory403", ActorsHistory403),
+			"404": decodeError("ActorsHistory404", ActorsHistory404),
+			"410": decodeError("ActorsHistory410", ActorsHistory410),
+			"503": decodeError("ActorsHistory503", ActorsHistory503),
+			orElse: unexpectedStatus
+		}))))),
+		"actorsErase": (organization, app, actor, key, options) => __makePathRequest(del, [
+			organization,
+			app,
+			actor,
+			key
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/actors/" + __encodePathParam(actor) + "/" + __encodePathParam(key)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"401": decodeError("ActorsErase401", ActorsErase401),
+			"403": decodeError("ActorsErase403", ActorsErase403),
+			"404": decodeError("ActorsErase404", ActorsErase404),
+			"428": decodeError("ActorsErase428", ActorsErase428),
+			"503": decodeError("ActorsErase503", ActorsErase503),
+			"204": () => void_,
+			orElse: unexpectedStatus
+		}))))),
+		"actorsExportShard": (organization, app, shard, options) => __makePathRequest(get, [
+			organization,
+			app,
+			shard
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/export/shards/" + __encodePathParam(shard)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(ActorsExportShard200),
+			"401": decodeError("ActorsExportShard401", ActorsExportShard401),
+			"403": decodeError("ActorsExportShard403", ActorsExportShard403),
+			"404": decodeError("ActorsExportShard404", ActorsExportShard404),
+			"503": decodeError("ActorsExportShard503", ActorsExportShard503),
+			orElse: unexpectedStatus
+		}))))),
+		"actorsExportSnapshot": (organization, app, options) => __makePathRequest(post, [organization, app], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/export/snapshots").pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(ActorsExportSnapshot201),
+			"401": decodeError("ActorsExportSnapshot401", ActorsExportSnapshot401),
+			"403": decodeError("ActorsExportSnapshot403", ActorsExportSnapshot403),
+			"404": decodeError("ActorsExportSnapshot404", ActorsExportSnapshot404),
+			"410": decodeError("ActorsExportSnapshot410", ActorsExportSnapshot410),
+			"503": decodeError("ActorsExportSnapshot503", ActorsExportSnapshot503),
+			orElse: unexpectedStatus
+		}))))),
+		"actorsExportRead": (organization, app, snapshot, options) => __makePathRequest(get, [
+			organization,
+			app,
+			snapshot
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/export/snapshots/" + __encodePathParam(snapshot)).pipe(flatMap((request) => request.pipe(setUrlParams({
+			"actor": options.params["actor"],
+			"key": options.params["key"],
+			"length": options.params["length"],
+			"offset": options.params["offset"]
+		}), withResponse(options.config)(matchStatus({
+			"2xx": decodeBinary,
+			"401": decodeError("ActorsExportRead401", ActorsExportRead401),
+			"403": decodeError("ActorsExportRead403", ActorsExportRead403),
+			"404": decodeError("ActorsExportRead404", ActorsExportRead404),
+			"410": decodeError("ActorsExportRead410", ActorsExportRead410),
+			"503": decodeError("ActorsExportRead503", ActorsExportRead503),
+			orElse: unexpectedStatus
+		}))))),
+		"actorsExportReadStream": (organization, app, snapshot, options) => unwrap(__makePathRequest(get, [
+			organization,
+			app,
+			snapshot
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/export/snapshots/" + __encodePathParam(snapshot)).pipe(map((request) => request.pipe(setUrlParams({
+			"actor": options.params["actor"],
+			"key": options.params["key"],
+			"length": options.params["length"],
+			"offset": options.params["offset"]
+		}), binaryRequest)))),
+		"actorsExportFiles": (organization, app, snapshot, options) => __makePathRequest(get, [
+			organization,
+			app,
+			snapshot
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/export/snapshots/" + __encodePathParam(snapshot) + "/files").pipe(flatMap((request) => request.pipe(setUrlParams({
+			"actor": options.params["actor"],
+			"after": options.params["after"],
+			"key": options.params["key"]
+		}), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(ActorsExportFiles200),
+			"401": decodeError("ActorsExportFiles401", ActorsExportFiles401),
+			"403": decodeError("ActorsExportFiles403", ActorsExportFiles403),
+			"404": decodeError("ActorsExportFiles404", ActorsExportFiles404),
+			"410": decodeError("ActorsExportFiles410", ActorsExportFiles410),
+			"503": decodeError("ActorsExportFiles503", ActorsExportFiles503),
+			orElse: unexpectedStatus
+		}))))),
+		"actorsExportFileRead": (organization, app, snapshot, sha256, options) => __makePathRequest(get, [
+			organization,
+			app,
+			snapshot,
+			sha256
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/export/snapshots/" + __encodePathParam(snapshot) + "/files/" + __encodePathParam(sha256)).pipe(flatMap((request) => request.pipe(setUrlParams({
+			"actor": options.params["actor"],
+			"key": options.params["key"],
+			"length": options.params["length"],
+			"offset": options.params["offset"]
+		}), withResponse(options.config)(matchStatus({
+			"2xx": decodeBinary,
+			"401": decodeError("ActorsExportFileRead401", ActorsExportFileRead401),
+			"403": decodeError("ActorsExportFileRead403", ActorsExportFileRead403),
+			"404": decodeError("ActorsExportFileRead404", ActorsExportFileRead404),
+			"410": decodeError("ActorsExportFileRead410", ActorsExportFileRead410),
+			"503": decodeError("ActorsExportFileRead503", ActorsExportFileRead503),
+			orElse: unexpectedStatus
+		}))))),
+		"actorsExportFileReadStream": (organization, app, snapshot, sha256, options) => unwrap(__makePathRequest(get, [
+			organization,
+			app,
+			snapshot,
+			sha256
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/export/snapshots/" + __encodePathParam(snapshot) + "/files/" + __encodePathParam(sha256)).pipe(map((request) => request.pipe(setUrlParams({
+			"actor": options.params["actor"],
+			"key": options.params["key"],
+			"length": options.params["length"],
+			"offset": options.params["offset"]
+		}), binaryRequest)))),
+		"actorsExec": (organization, app, actor, key, options) => __makePathRequest(post, [
+			organization,
+			app,
+			actor,
+			key
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/actors/" + __encodePathParam(actor) + "/" + __encodePathParam(key) + "/exec").pipe(flatMap((request) => request.pipe(setUrlParams({ "environment": options.params?.["environment"] }), bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(ActorsExec200),
+			"401": decodeError("ActorsExec401", ActorsExec401),
+			"403": decodeError("ActorsExec403", ActorsExec403),
+			"404": decodeError("ActorsExec404", ActorsExec404),
+			"409": decodeError("ActorsExec409", ActorsExec409),
+			"410": decodeError("ActorsExec410", ActorsExec410),
+			"503": decodeError("ActorsExec503", ActorsExec503),
+			orElse: unexpectedStatus
+		}))))),
+		"actorForksCreate": (organization, app, environment, actor, key, options) => __makePathRequest(post, [
+			organization,
+			app,
+			environment,
+			actor,
+			key
+		], () => "/v1/organizations/" + __encodePathParam(organization) + "/apps/" + __encodePathParam(app) + "/environments/" + __encodePathParam(environment) + "/actors/" + __encodePathParam(actor) + "/" + __encodePathParam(key) + "/forks").pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(ActorForksCreate201),
+			"401": decodeError("ActorForksCreate401", ActorForksCreate401),
+			"403": decodeError("ActorForksCreate403", ActorForksCreate403),
+			"404": decodeError("ActorForksCreate404", ActorForksCreate404),
+			"409": decodeError("ActorForksCreate409", ActorForksCreate409),
+			"410": decodeError("ActorForksCreate410", ActorForksCreate410),
+			"428": decodeError("ActorForksCreate428", ActorForksCreate428),
+			"503": decodeError("ActorForksCreate503", ActorForksCreate503),
+			orElse: unexpectedStatus
+		}))))),
+		"membersList": (organization, options) => __makePathRequest(get, [organization], () => "/v1/organizations/" + __encodePathParam(organization) + "/members").pipe(flatMap((request) => request.pipe(setUrlParams({
+			"cursor": options?.params?.["cursor"],
+			"limit": options?.params?.["limit"]
+		}), withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(MembersList200),
+			"401": decodeError("MembersList401", MembersList401),
+			"403": decodeError("MembersList403", MembersList403),
+			"404": decodeError("MembersList404", MembersList404),
+			"503": decodeError("MembersList503", MembersList503),
+			orElse: unexpectedStatus
+		}))))),
+		"membersAdd": (organization, options) => __makePathRequest(post, [organization], () => "/v1/organizations/" + __encodePathParam(organization) + "/members").pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(MembersAdd201),
+			"401": decodeError("MembersAdd401", MembersAdd401),
+			"403": decodeError("MembersAdd403", MembersAdd403),
+			"404": decodeError("MembersAdd404", MembersAdd404),
+			"409": decodeError("MembersAdd409", MembersAdd409),
+			"503": decodeError("MembersAdd503", MembersAdd503),
+			orElse: unexpectedStatus
+		}))))),
+		"membersRemove": (organization, member, options) => __makePathRequest(del, [organization, member], () => "/v1/organizations/" + __encodePathParam(organization) + "/members/" + __encodePathParam(member)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"401": decodeError("MembersRemove401", MembersRemove401),
+			"403": decodeError("MembersRemove403", MembersRemove403),
+			"404": decodeError("MembersRemove404", MembersRemove404),
+			"428": decodeError("MembersRemove428", MembersRemove428),
+			"503": decodeError("MembersRemove503", MembersRemove503),
+			"204": () => void_,
+			orElse: unexpectedStatus
+		}))))),
+		"membersChangeRole": (organization, member, options) => __makePathRequest(patch, [organization, member], () => "/v1/organizations/" + __encodePathParam(organization) + "/members/" + __encodePathParam(member)).pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(MembersChangeRole200),
+			"401": decodeError("MembersChangeRole401", MembersChangeRole401),
+			"403": decodeError("MembersChangeRole403", MembersChangeRole403),
+			"404": decodeError("MembersChangeRole404", MembersChangeRole404),
+			"503": decodeError("MembersChangeRole503", MembersChangeRole503),
+			orElse: unexpectedStatus
+		}))))),
+		"invitationsList": (organization, options) => __makePathRequest(get, [organization], () => "/v1/organizations/" + __encodePathParam(organization) + "/invitations").pipe(flatMap((request) => request.pipe(setUrlParams({
+			"cursor": options?.params?.["cursor"],
+			"limit": options?.params?.["limit"]
+		}), withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(InvitationsList200),
+			"401": decodeError("InvitationsList401", InvitationsList401),
+			"403": decodeError("InvitationsList403", InvitationsList403),
+			"404": decodeError("InvitationsList404", InvitationsList404),
+			"503": decodeError("InvitationsList503", InvitationsList503),
+			orElse: unexpectedStatus
+		}))))),
+		"invitationsCreate": (organization, options) => __makePathRequest(post, [organization], () => "/v1/organizations/" + __encodePathParam(organization) + "/invitations").pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(InvitationsCreate201),
+			"401": decodeError("InvitationsCreate401", InvitationsCreate401),
+			"403": decodeError("InvitationsCreate403", InvitationsCreate403),
+			"404": decodeError("InvitationsCreate404", InvitationsCreate404),
+			"409": decodeError("InvitationsCreate409", InvitationsCreate409),
+			"503": decodeError("InvitationsCreate503", InvitationsCreate503),
+			orElse: unexpectedStatus
+		}))))),
+		"invitationsRevoke": (organization, invitation, options) => __makePathRequest(del, [organization, invitation], () => "/v1/organizations/" + __encodePathParam(organization) + "/invitations/" + __encodePathParam(invitation)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"401": decodeError("InvitationsRevoke401", InvitationsRevoke401),
+			"403": decodeError("InvitationsRevoke403", InvitationsRevoke403),
+			"404": decodeError("InvitationsRevoke404", InvitationsRevoke404),
+			"503": decodeError("InvitationsRevoke503", InvitationsRevoke503),
+			"204": () => void_,
+			orElse: unexpectedStatus
+		}))))),
+		"invitationsAccept": (organization, invitation, options) => __makePathRequest(post, [organization, invitation], () => "/v1/organizations/" + __encodePathParam(organization) + "/invitations/" + __encodePathParam(invitation) + "/accept").pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(InvitationsAccept201),
+			"401": decodeError("InvitationsAccept401", InvitationsAccept401),
+			"403": decodeError("InvitationsAccept403", InvitationsAccept403),
+			"404": decodeError("InvitationsAccept404", InvitationsAccept404),
+			"409": decodeError("InvitationsAccept409", InvitationsAccept409),
+			"503": decodeError("InvitationsAccept503", InvitationsAccept503),
+			orElse: unexpectedStatus
+		}))))),
+		"usageGet": (organization, options) => __makePathRequest(get, [organization], () => "/v1/organizations/" + __encodePathParam(organization) + "/usage").pipe(flatMap((request) => request.pipe(setUrlParams({
+			"app": options?.params?.["app"],
+			"key": options?.params?.["key"],
+			"period": options?.params?.["period"]
+		}), withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(UsageGet200),
+			"401": decodeError("UsageGet401", UsageGet401),
+			"403": decodeError("UsageGet403", UsageGet403),
+			"404": decodeError("UsageGet404", UsageGet404),
+			"503": decodeError("UsageGet503", UsageGet503),
+			orElse: unexpectedStatus
+		}))))),
+		"usageForecast": (organization, options) => __makePathRequest(get, [organization], () => "/v1/organizations/" + __encodePathParam(organization) + "/usage/forecast").pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(UsageForecast200),
+			"401": decodeError("UsageForecast401", UsageForecast401),
+			"403": decodeError("UsageForecast403", UsageForecast403),
+			"404": decodeError("UsageForecast404", UsageForecast404),
+			"503": decodeError("UsageForecast503", UsageForecast503),
+			orElse: unexpectedStatus
+		}))))),
+		"billingGet": (organization, options) => __makePathRequest(get, [organization], () => "/v1/organizations/" + __encodePathParam(organization) + "/billing").pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(BillingGet200),
+			"401": decodeError("BillingGet401", BillingGet401),
+			"403": decodeError("BillingGet403", BillingGet403),
+			"404": decodeError("BillingGet404", BillingGet404),
+			"503": decodeError("BillingGet503", BillingGet503),
+			orElse: unexpectedStatus
+		}))))),
+		"billingCancel": (organization, options) => __makePathRequest(del, [organization], () => "/v1/organizations/" + __encodePathParam(organization) + "/billing").pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(BillingCancel200),
+			"401": decodeError("BillingCancel401", BillingCancel401),
+			"403": decodeError("BillingCancel403", BillingCancel403),
+			"404": decodeError("BillingCancel404", BillingCancel404),
+			"428": decodeError("BillingCancel428", BillingCancel428),
+			"503": decodeError("BillingCancel503", BillingCancel503),
+			orElse: unexpectedStatus
+		}))))),
+		"billingCheckout": (organization, options) => __makePathRequest(post, [organization], () => "/v1/organizations/" + __encodePathParam(organization) + "/billing/checkout").pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(BillingCheckout201),
+			"401": decodeError("BillingCheckout401", BillingCheckout401),
+			"403": decodeError("BillingCheckout403", BillingCheckout403),
+			"404": decodeError("BillingCheckout404", BillingCheckout404),
+			"503": decodeError("BillingCheckout503", BillingCheckout503),
+			orElse: unexpectedStatus
+		}))))),
+		"billingSetCap": (organization, options) => __makePathRequest(put, [organization], () => "/v1/organizations/" + __encodePathParam(organization) + "/billing/cap").pipe(flatMap((request) => request.pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(BillingSetCap200),
+			"401": decodeError("BillingSetCap401", BillingSetCap401),
+			"402": decodeError("BillingSetCap402", BillingSetCap402),
+			"403": decodeError("BillingSetCap403", BillingSetCap403),
+			"404": decodeError("BillingSetCap404", BillingSetCap404),
+			"428": decodeError("BillingSetCap428", BillingSetCap428),
+			"503": decodeError("BillingSetCap503", BillingSetCap503),
+			orElse: unexpectedStatus
+		}))))),
+		"billingInvoices": (organization, options) => __makePathRequest(get, [organization], () => "/v1/organizations/" + __encodePathParam(organization) + "/billing/invoices").pipe(flatMap((request) => request.pipe(setUrlParams({
+			"cursor": options?.params?.["cursor"],
+			"limit": options?.params?.["limit"]
+		}), withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(BillingInvoices200),
+			"401": decodeError("BillingInvoices401", BillingInvoices401),
+			"403": decodeError("BillingInvoices403", BillingInvoices403),
+			"404": decodeError("BillingInvoices404", BillingInvoices404),
+			"503": decodeError("BillingInvoices503", BillingInvoices503),
+			orElse: unexpectedStatus
+		}))))),
+		"tokensExchange": (options) => post("/v1/tokens").pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(TokensExchange200),
+			"401": decodeError("TokensExchange401", TokensExchange401),
+			"503": decodeError("TokensExchange503", TokensExchange503),
+			orElse: unexpectedStatus
+		}))),
+		"signInSendCode": (options) => post("/v1/sign-in/codes").pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(SignInSendCode202),
+			"429": decodeError("SignInSendCode429", SignInSendCode429),
+			orElse: unexpectedStatus
+		}))),
+		"signInVerifyCode": (options) => post("/v1/sign-in/sessions").pipe(bodyJsonUnsafe(options.payload), withResponse(options.config)(matchStatus({
+			"2xx": decodeSuccess(SignInVerifyCode201),
+			"401": decodeError("SignInVerifyCode401", SignInVerifyCode401),
+			"422": decodeError("SignInVerifyCode422", SignInVerifyCode422),
+			"429": decodeError("SignInVerifyCode429", SignInVerifyCode429),
+			orElse: unexpectedStatus
+		}))),
+		"sessionsList": (options) => get("/v1/sessions").pipe(setUrlParams({
+			"cursor": options?.params?.["cursor"],
+			"limit": options?.params?.["limit"]
+		}), withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(SessionsList200),
+			"401": decodeError("SessionsList401", SessionsList401),
+			"503": decodeError("SessionsList503", SessionsList503),
+			orElse: unexpectedStatus
+		}))),
+		"sessionsRevoke": (session, options) => __makePathRequest(del, [session], () => "/v1/sessions/" + __encodePathParam(session)).pipe(flatMap((request) => request.pipe(withResponse(options?.config)(matchStatus({
+			"401": decodeError("SessionsRevoke401", SessionsRevoke401),
+			"404": decodeError("SessionsRevoke404", SessionsRevoke404),
+			"503": decodeError("SessionsRevoke503", SessionsRevoke503),
+			"204": () => void_,
+			orElse: unexpectedStatus
+		}))))),
+		"accountGet": (options) => get("/v1/account").pipe(withResponse(options?.config)(matchStatus({
+			"2xx": decodeSuccess(AccountGet200),
+			"401": decodeError("AccountGet401", AccountGet401),
+			"404": decodeError("AccountGet404", AccountGet404),
+			"503": decodeError("AccountGet503", AccountGet503),
+			orElse: unexpectedStatus
+		}))),
+		"accountDelete": (options) => del("/v1/account").pipe(withResponse(options?.config)(matchStatus({
+			"401": decodeError("AccountDelete401", AccountDelete401),
+			"403": decodeError("AccountDelete403", AccountDelete403),
+			"404": decodeError("AccountDelete404", AccountDelete404),
+			"409": decodeError("AccountDelete409", AccountDelete409),
+			"428": decodeError("AccountDelete428", AccountDelete428),
+			"503": decodeError("AccountDelete503", AccountDelete503),
+			"204": () => void_,
+			orElse: unexpectedStatus
+		})))
+	};
+};
+var CloudClientErrorImpl = class extends Error {};
+const CloudClientError = (tag, cause, response) => new CloudClientErrorImpl({
+	_tag: tag,
+	cause,
+	response,
+	request: response.request
+});
+export { mapRequestEffect as _, Deploy as a, LogLine as c, make as d, HttpClient as f, mapRequest as g, make$1 as h, CustomerHostname as i, LogsReadParams as l, layerMergedContext as m, BuildManifest as n, EnvironmentName as o, filterStatusOk as p, ConfirmationRequiredErrorEncoded as r, ExportSnapshot as s, AppName as t, OrganizationName as u, transformResponse as v, isHttpMethod as y };