@leavepulse/control-sdk 0.3.31

package/client.ts

@@ -0,0 +1,320 @@
+// Generated from the LeavePulse contract. Do not edit.
+import type { Transport } from "./runtime/transport";
+import { IdentityMap } from "./runtime/cache";
+import { MemoryEtagStore, fetchCached } from "./runtime/etag-store";
+import type { EtagStore } from "./runtime/etag-store";
+import type { Identified } from "./runtime/cache";
+import { extractId } from "./runtime/resource";
+import { MalformedResponse } from "./runtime/errors";
+import type { RealtimeTransport } from "./runtime/realtime";
+import { ControlAgentRelease } from "./resources/ControlAgentRelease";
+import { ControlAlert } from "./resources/ControlAlert";
+import { ControlCfAccount } from "./resources/ControlCfAccount";
+import { ControlDcimAcceptance } from "./resources/ControlDcimAcceptance";
+import { ControlDcimCable } from "./resources/ControlDcimCable";
+import { ControlDcimComponent } from "./resources/ControlDcimComponent";
+import { ControlDcimDevice } from "./resources/ControlDcimDevice";
+import { ControlDcimFeed } from "./resources/ControlDcimFeed";
+import { ControlDcimLocation } from "./resources/ControlDcimLocation";
+import { ControlDcimOutlet } from "./resources/ControlDcimOutlet";
+import { ControlDcimPdu } from "./resources/ControlDcimPdu";
+import { ControlDcimPort } from "./resources/ControlDcimPort";
+import { ControlDcimPowerLink } from "./resources/ControlDcimPowerLink";
+import { ControlDcimRack } from "./resources/ControlDcimRack";
+import { ControlEdge } from "./resources/ControlEdge";
+import { ControlEnrollToken } from "./resources/ControlEnrollToken";
+import { ControlEnvGroup } from "./resources/ControlEnvGroup";
+import { ControlHost } from "./resources/ControlHost";
+import { ControlNode } from "./resources/ControlNode";
+import { ControlProject } from "./resources/ControlProject";
+import { ControlRule } from "./resources/ControlRule";
+import { ControlSchedule } from "./resources/ControlSchedule";
+import { ControlService } from "./resources/ControlService";
+import { AuthNs, ControlNs } from "./procedures";
+
+export interface ClientContext {
+	transport: Transport;
+	cache: IdentityMap;
+	etagStore: EtagStore;
+	hydrate(type: string, payload: unknown, dataRoot?: string): unknown;
+	hydrateMany(type: string, raw: unknown): unknown[];
+	realtime: RealtimeTransport;
+}
+
+export class LeavePulse {
+	private readonly ctx: ClientContext;
+	private _controlagentrelease?: ControlAgentRelease;
+	private _controlalert?: ControlAlert;
+	private _controlproject?: ControlProject;
+	readonly auth: AuthNs;
+	readonly control: ControlNs;
+
+	constructor(
+		transport: Transport,
+		realtime?: RealtimeTransport,
+		etagStore?: EtagStore,
+	) {
+		const cache = new IdentityMap();
+		const etags = etagStore ?? new MemoryEtagStore();
+		const realtimeOrThrow =
+			realtime ??
+			(new Proxy(
+				{},
+				{
+					get() {
+						throw new Error(
+							"realtime not configured: pass a RealtimeTransport to the client",
+						);
+					},
+				},
+			) as RealtimeTransport);
+		this.ctx = {
+			transport,
+			cache,
+			etagStore: etags,
+			realtime: realtimeOrThrow,
+			hydrate: (type, payload, dataRoot) =>
+				this.hydrate(type, payload, dataRoot),
+			hydrateMany: (type, raw) =>
+				Array.isArray(raw) ? raw.map((d) => this.hydrate(type, d)) : [],
+		};
+		this.auth = new AuthNs(this.ctx);
+		this.control = new ControlNs(this.ctx);
+	}
+
+	get controlagentrelease(): ControlAgentRelease {
+		this._controlagentrelease ??= new ControlAgentRelease(
+			{} as never,
+			this.ctx,
+		);
+		return this._controlagentrelease;
+	}
+
+	get controlalert(): ControlAlert {
+		this._controlalert ??= new ControlAlert({} as never, this.ctx);
+		return this._controlalert;
+	}
+
+	controlcfaccount(id: string): ControlCfAccount {
+		return this.ctx.cache.ensure(
+			"ControlCfAccount",
+			id,
+			() => new ControlCfAccount({ id } as never, this.ctx),
+		) as ControlCfAccount;
+	}
+
+	controldcimacceptance(id: string): ControlDcimAcceptance {
+		return this.ctx.cache.ensure(
+			"ControlDcimAcceptance",
+			id,
+			() => new ControlDcimAcceptance({ id } as never, this.ctx),
+		) as ControlDcimAcceptance;
+	}
+
+	controldcimcable(id: string): ControlDcimCable {
+		return this.ctx.cache.ensure(
+			"ControlDcimCable",
+			id,
+			() => new ControlDcimCable({ id } as never, this.ctx),
+		) as ControlDcimCable;
+	}
+
+	controldcimcomponent(id: string): ControlDcimComponent {
+		return this.ctx.cache.ensure(
+			"ControlDcimComponent",
+			id,
+			() => new ControlDcimComponent({ id } as never, this.ctx),
+		) as ControlDcimComponent;
+	}
+
+	controldcimdevice(id: string): ControlDcimDevice {
+		return this.ctx.cache.ensure(
+			"ControlDcimDevice",
+			id,
+			() => new ControlDcimDevice({ id } as never, this.ctx),
+		) as ControlDcimDevice;
+	}
+
+	controldcimfeed(id: string): ControlDcimFeed {
+		return this.ctx.cache.ensure(
+			"ControlDcimFeed",
+			id,
+			() => new ControlDcimFeed({ id } as never, this.ctx),
+		) as ControlDcimFeed;
+	}
+
+	controldcimlocation(id: string): ControlDcimLocation {
+		return this.ctx.cache.ensure(
+			"ControlDcimLocation",
+			id,
+			() => new ControlDcimLocation({ id } as never, this.ctx),
+		) as ControlDcimLocation;
+	}
+
+	controldcimoutlet(id: string): ControlDcimOutlet {
+		return this.ctx.cache.ensure(
+			"ControlDcimOutlet",
+			id,
+			() => new ControlDcimOutlet({ id } as never, this.ctx),
+		) as ControlDcimOutlet;
+	}
+
+	controldcimpdu(id: string): ControlDcimPdu {
+		return this.ctx.cache.ensure(
+			"ControlDcimPdu",
+			id,
+			() => new ControlDcimPdu({ id } as never, this.ctx),
+		) as ControlDcimPdu;
+	}
+
+	controldcimport(id: string): ControlDcimPort {
+		return this.ctx.cache.ensure(
+			"ControlDcimPort",
+			id,
+			() => new ControlDcimPort({ id } as never, this.ctx),
+		) as ControlDcimPort;
+	}
+
+	controldcimpowerlink(id: string): ControlDcimPowerLink {
+		return this.ctx.cache.ensure(
+			"ControlDcimPowerLink",
+			id,
+			() => new ControlDcimPowerLink({ id } as never, this.ctx),
+		) as ControlDcimPowerLink;
+	}
+
+	controldcimrack(id: string): ControlDcimRack {
+		return this.ctx.cache.ensure(
+			"ControlDcimRack",
+			id,
+			() => new ControlDcimRack({ id } as never, this.ctx),
+		) as ControlDcimRack;
+	}
+
+	controledge(id: string): ControlEdge {
+		return this.ctx.cache.ensure(
+			"ControlEdge",
+			id,
+			() => new ControlEdge({ id } as never, this.ctx),
+		) as ControlEdge;
+	}
+
+	controlenrolltoken(id: string): ControlEnrollToken {
+		return this.ctx.cache.ensure(
+			"ControlEnrollToken",
+			id,
+			() => new ControlEnrollToken({ id } as never, this.ctx),
+		) as ControlEnrollToken;
+	}
+
+	controlenvgroup(id: string): ControlEnvGroup {
+		return this.ctx.cache.ensure(
+			"ControlEnvGroup",
+			id,
+			() => new ControlEnvGroup({ id } as never, this.ctx),
+		) as ControlEnvGroup;
+	}
+
+	controlhost(id: string): ControlHost {
+		return this.ctx.cache.ensure(
+			"ControlHost",
+			id,
+			() => new ControlHost({ id } as never, this.ctx),
+		) as ControlHost;
+	}
+
+	controlnode(id: string): ControlNode {
+		return this.ctx.cache.ensure(
+			"ControlNode",
+			id,
+			() => new ControlNode({ id } as never, this.ctx),
+		) as ControlNode;
+	}
+
+	get controlproject(): ControlProject {
+		this._controlproject ??= new ControlProject({} as never, this.ctx);
+		return this._controlproject;
+	}
+
+	controlrule(id: string): ControlRule {
+		return this.ctx.cache.ensure(
+			"ControlRule",
+			id,
+			() => new ControlRule({ id } as never, this.ctx),
+		) as ControlRule;
+	}
+
+	controlschedule(id: string): ControlSchedule {
+		return this.ctx.cache.ensure(
+			"ControlSchedule",
+			id,
+			() => new ControlSchedule({ id } as never, this.ctx),
+		) as ControlSchedule;
+	}
+
+	controlservice(id: string): ControlService {
+		return this.ctx.cache.ensure(
+			"ControlService",
+			id,
+			() => new ControlService({ id } as never, this.ctx),
+		) as ControlService;
+	}
+
+	/**
+	 * Normalize a payload into a resource instance. When `dataRoot` is
+	 * set the payload is an envelope (`{ project, servers }`): the core
+	 * object is unwrapped and sibling fields (links) are merged onto it,
+	 * so the resource sees a flat object with `id` at the top.
+	 */
+	private hydrate(type: string, payload: unknown, dataRoot?: string): unknown {
+		type Hydrated = { id: string | number } & Record<string, unknown>;
+		const factories: Record<string, (d: Hydrated) => Identified> = {
+			ControlAgentRelease: (d) => new ControlAgentRelease(d as never, this.ctx),
+			ControlAlert: (d) => new ControlAlert(d as never, this.ctx),
+			ControlCfAccount: (d) => new ControlCfAccount(d as never, this.ctx),
+			ControlDcimAcceptance: (d) =>
+				new ControlDcimAcceptance(d as never, this.ctx),
+			ControlDcimCable: (d) => new ControlDcimCable(d as never, this.ctx),
+			ControlDcimComponent: (d) =>
+				new ControlDcimComponent(d as never, this.ctx),
+			ControlDcimDevice: (d) => new ControlDcimDevice(d as never, this.ctx),
+			ControlDcimFeed: (d) => new ControlDcimFeed(d as never, this.ctx),
+			ControlDcimLocation: (d) => new ControlDcimLocation(d as never, this.ctx),
+			ControlDcimOutlet: (d) => new ControlDcimOutlet(d as never, this.ctx),
+			ControlDcimPdu: (d) => new ControlDcimPdu(d as never, this.ctx),
+			ControlDcimPort: (d) => new ControlDcimPort(d as never, this.ctx),
+			ControlDcimPowerLink: (d) =>
+				new ControlDcimPowerLink(d as never, this.ctx),
+			ControlDcimRack: (d) => new ControlDcimRack(d as never, this.ctx),
+			ControlEdge: (d) => new ControlEdge(d as never, this.ctx),
+			ControlEnrollToken: (d) => new ControlEnrollToken(d as never, this.ctx),
+			ControlEnvGroup: (d) => new ControlEnvGroup(d as never, this.ctx),
+			ControlHost: (d) => new ControlHost(d as never, this.ctx),
+			ControlNode: (d) => new ControlNode(d as never, this.ctx),
+			ControlProject: (d) => new ControlProject(d as never, this.ctx),
+			ControlRule: (d) => new ControlRule(d as never, this.ctx),
+			ControlSchedule: (d) => new ControlSchedule(d as never, this.ctx),
+			ControlService: (d) => new ControlService(d as never, this.ctx),
+		};
+		const idPaths: Record<string, readonly string[]> = {};
+		const factory = factories[type];
+		if (!factory) return payload;
+		let data = payload as Record<string, unknown>;
+		if (dataRoot && payload && typeof payload === "object") {
+			const { [dataRoot]: core, ...siblings } = payload as Record<
+				string,
+				unknown
+			>;
+			data = { ...(core as Record<string, unknown>), ...siblings };
+		}
+		const hydrated = data as Hydrated;
+		const id = extractId(hydrated, idPaths[type]);
+		if (id === "") {
+			throw new MalformedResponse(
+				`${type} payload has no id field to identity-map on`,
+				payload,
+			);
+		}
+		return this.ctx.cache.upsert(type, id, hydrated, () => factory(hydrated));
+	}
+}

package/index.ts

@@ -0,0 +1,110 @@
+// Generated from the LeavePulse contract. Do not edit.
+export { LeavePulse } from "./client";
+export type { ClientContext } from "./client";
+export type * from "./models";
+export type { Snowflake } from "./runtime/snowflake";
+export { ControlAgentRelease } from "./resources/ControlAgentRelease";
+export { ControlAlert } from "./resources/ControlAlert";
+export { ControlCfAccount } from "./resources/ControlCfAccount";
+export { ControlDcimAcceptance } from "./resources/ControlDcimAcceptance";
+export { ControlDcimCable } from "./resources/ControlDcimCable";
+export { ControlDcimComponent } from "./resources/ControlDcimComponent";
+export { ControlDcimDevice } from "./resources/ControlDcimDevice";
+export { ControlDcimFeed } from "./resources/ControlDcimFeed";
+export { ControlDcimLocation } from "./resources/ControlDcimLocation";
+export { ControlDcimOutlet } from "./resources/ControlDcimOutlet";
+export { ControlDcimPdu } from "./resources/ControlDcimPdu";
+export { ControlDcimPort } from "./resources/ControlDcimPort";
+export { ControlDcimPowerLink } from "./resources/ControlDcimPowerLink";
+export { ControlDcimRack } from "./resources/ControlDcimRack";
+export { ControlEdge } from "./resources/ControlEdge";
+export { ControlEnrollToken } from "./resources/ControlEnrollToken";
+export { ControlEnvGroup } from "./resources/ControlEnvGroup";
+export { ControlHost } from "./resources/ControlHost";
+export { ControlNode } from "./resources/ControlNode";
+export { ControlProject } from "./resources/ControlProject";
+export { ControlRule } from "./resources/ControlRule";
+export { ControlSchedule } from "./resources/ControlSchedule";
+export { ControlService } from "./resources/ControlService";
+export type {
+	Transport,
+	TransportRequest,
+	HttpMethod,
+	Channel,
+	RetryOptions,
+	ConditionalResult,
+	MultipartBody,
+} from "./runtime/transport";
+export {
+	BearerTransport,
+	buildPath,
+	buildFormData,
+	LeavePulseFile,
+} from "./runtime/transport";
+export { parseJson } from "./runtime/json";
+export {
+	LeavePulseError,
+	HTTPException,
+	BadRequest,
+	UnprocessableEntity,
+	Unauthorized,
+	Forbidden,
+	NotFound,
+	Conflict,
+	RateLimited,
+	ServerError,
+	MalformedResponse,
+	parseProblem,
+	httpErrorFor,
+	fieldErrorsOf,
+} from "./runtime/errors";
+export type { ProblemDetails, FieldError } from "./runtime/errors";
+export { pollDeviceToken, DeviceFlowError } from "./runtime/device";
+export type {
+	DevicePollStatus,
+	DeviceTokenResponse,
+	DevicePollOptions,
+} from "./runtime/device";
+export {
+	MemoryEtagStore,
+	LocalStorageEtagStore,
+	IndexedDbEtagStore,
+	fetchCached,
+	defaultCacheKey,
+} from "./runtime/etag-store";
+export type {
+	EtagStore,
+	EtagEntry,
+	FetchCachedOptions,
+} from "./runtime/etag-store";
+export { CachePolicy } from "./runtime/cache-policy";
+export type {
+	PolicyConfig,
+	PolicyEntry,
+	PolicyState,
+	QueryEntry,
+	EnsureOptions,
+} from "./runtime/cache-policy";
+export { Page } from "./runtime/page";
+export { IdentityMap } from "./runtime/cache";
+export type { Identified } from "./runtime/cache";
+export {
+	RealtimeTransport,
+	TopicSubscription,
+	toRealtimeError,
+} from "./runtime/realtime";
+export type {
+	RealtimeEvent,
+	RealtimeMessage,
+	RealtimeHandler,
+	RealtimeError,
+	WebSocketLike,
+	RealtimeTransportOptions,
+} from "./runtime/realtime";
+export { RealtimeClient } from "./runtime/realtime-client";
+export type {
+	RealtimeClientOptions,
+	RealtimeEnvelope,
+	RealtimeEventKind,
+	BinaryWebSocketLike,
+} from "./runtime/realtime-client";

package/models.ts

@@ -0,0 +1,232 @@
+// Named type aliases over the generated schema maps. Generated — do not edit.
+import type { components } from "./types";
+import type { components as authComponents } from "./auth-types";
+
+export type AcceptAcceptanceRequest =
+	components["schemas"]["AcceptAcceptanceRequest"];
+export type AcceptanceItemDTO = components["schemas"]["AcceptanceItemDTO"];
+export type AcceptanceItemInput = components["schemas"]["AcceptanceItemInput"];
+export type AcceptanceRecordDTO = components["schemas"]["AcceptanceRecordDTO"];
+export type AcceptanceRecordListResponse =
+	components["schemas"]["AcceptanceRecordListResponse"];
+export type AffectedDeviceDTO = components["schemas"]["AffectedDeviceDTO"];
+export type AgentReleaseDTO = components["schemas"]["AgentReleaseDTO"];
+export type AlertDTO = components["schemas"]["AlertDTO"];
+export type AlertListResponse = components["schemas"]["AlertListResponse"];
+export type CableDTO = components["schemas"]["CableDTO"];
+export type CableListResponse = components["schemas"]["CableListResponse"];
+export type CableTerminalDTO = components["schemas"]["CableTerminalDTO"];
+export type CableTerminalInput = components["schemas"]["CableTerminalInput"];
+export type CanvasViewDTO = components["schemas"]["CanvasViewDTO"];
+export type CfAccountDTO = components["schemas"]["CfAccountDTO"];
+export type CfAccountListResponse =
+	components["schemas"]["CfAccountListResponse"];
+export type ComponentDTO = components["schemas"]["ComponentDTO"];
+export type ComponentListResponse =
+	components["schemas"]["ComponentListResponse"];
+export type ComposePreviewDTO = components["schemas"]["ComposePreviewDTO"];
+export type ConfigFileDTO = components["schemas"]["ConfigFileDTO"];
+export type ConnectPowerRequest = components["schemas"]["ConnectPowerRequest"];
+export type ContainerActionRequest =
+	components["schemas"]["ContainerActionRequest"];
+export type ContainerActionResponse =
+	components["schemas"]["ContainerActionResponse"];
+export type ContainerDTO = components["schemas"]["ContainerDTO"];
+export type CreateAcceptanceRequest =
+	components["schemas"]["CreateAcceptanceRequest"];
+export type CreateCableRequest = components["schemas"]["CreateCableRequest"];
+export type CreateCfAccountRequest =
+	components["schemas"]["CreateCfAccountRequest"];
+export type CreateComponentRequest =
+	components["schemas"]["CreateComponentRequest"];
+export type CreateDeviceRequest = components["schemas"]["CreateDeviceRequest"];
+export type CreateEnrollTokenRequest =
+	components["schemas"]["CreateEnrollTokenRequest"];
+export type CreateEnrollTokenResponse =
+	components["schemas"]["CreateEnrollTokenResponse"];
+export type CreateFeedRequest = components["schemas"]["CreateFeedRequest"];
+export type CreateLocationRequest =
+	components["schemas"]["CreateLocationRequest"];
+export type CreateOutletRequest = components["schemas"]["CreateOutletRequest"];
+export type CreatePduRequest = components["schemas"]["CreatePduRequest"];
+export type CreatePortRequest = components["schemas"]["CreatePortRequest"];
+export type CreateRackRequest = components["schemas"]["CreateRackRequest"];
+export type CreateRuleRequest = components["schemas"]["CreateRuleRequest"];
+export type CreateScheduleRequest =
+	components["schemas"]["CreateScheduleRequest"];
+export type DecommissionRequest = components["schemas"]["DecommissionRequest"];
+export type DecommissionResponse =
+	components["schemas"]["DecommissionResponse"];
+export type DeleteResultDTO = components["schemas"]["DeleteResultDTO"];
+export type DeployRequest = components["schemas"]["DeployRequest"];
+export type DeploymentDTO = components["schemas"]["DeploymentDTO"];
+export type DeploymentListResponse =
+	components["schemas"]["DeploymentListResponse"];
+export type DetectedExporterDTO = components["schemas"]["DetectedExporterDTO"];
+export type DeviceDTO = components["schemas"]["DeviceDTO"];
+export type DeviceListResponse = components["schemas"]["DeviceListResponse"];
+export type DiskCategory = components["schemas"]["DiskCategory"];
+export type DiskUsageDTO = components["schemas"]["DiskUsageDTO"];
+export type DisputeAcceptanceRequest =
+	components["schemas"]["DisputeAcceptanceRequest"];
+export type DnsRecordDTO = components["schemas"]["DnsRecordDTO"];
+export type DnsRecordListResponse =
+	components["schemas"]["DnsRecordListResponse"];
+export type DockerDfResponse = components["schemas"]["DockerDfResponse"];
+export type DockerPruneRequest = components["schemas"]["DockerPruneRequest"];
+export type DockerPruneResponse = components["schemas"]["DockerPruneResponse"];
+export type EdgeDTO = components["schemas"]["EdgeDTO"];
+export type EnrollTokenDTO = components["schemas"]["EnrollTokenDTO"];
+export type EnrollTokenListResponse =
+	components["schemas"]["EnrollTokenListResponse"];
+export type EnvGroupDTO = components["schemas"]["EnvGroupDTO"];
+export type EnvGroupListResponse =
+	components["schemas"]["EnvGroupListResponse"];
+export type FeedDTO = components["schemas"]["FeedDTO"];
+export type FeedListResponse = components["schemas"]["FeedListResponse"];
+export type FirewallActionResponse =
+	components["schemas"]["FirewallActionResponse"];
+export type FirewallBlockRequest =
+	components["schemas"]["FirewallBlockRequest"];
+export type FirewallRule = components["schemas"]["FirewallRule"];
+export type FirewallRulesResponse =
+	components["schemas"]["FirewallRulesResponse"];
+export type HostCapabilitiesDTO = components["schemas"]["HostCapabilitiesDTO"];
+export type HostDTO = components["schemas"]["HostDTO"];
+export type HostListResponse = components["schemas"]["HostListResponse"];
+export type InspectResponse = components["schemas"]["InspectResponse"];
+export type InstallExporterRequest =
+	components["schemas"]["InstallExporterRequest"];
+export type InstallExporterResponse =
+	components["schemas"]["InstallExporterResponse"];
+export type LocationDTO = components["schemas"]["LocationDTO"];
+export type LocationListResponse =
+	components["schemas"]["LocationListResponse"];
+export type NodeDTO = components["schemas"]["NodeDTO"];
+export type OutletDTO = components["schemas"]["OutletDTO"];
+export type OutletListResponse = components["schemas"]["OutletListResponse"];
+export type OwnerDTO = components["schemas"]["OwnerDTO"];
+export type OwnershipEventDTO = components["schemas"]["OwnershipEventDTO"];
+export type OwnershipEventListResponse =
+	components["schemas"]["OwnershipEventListResponse"];
+export type OwnershipInput = components["schemas"]["OwnershipInput"];
+export type PathHopDTO = components["schemas"]["PathHopDTO"];
+export type PduDTO = components["schemas"]["PduDTO"];
+export type PduListResponse = components["schemas"]["PduListResponse"];
+export type PlacementDTO = components["schemas"]["PlacementDTO"];
+export type PlacementInput = components["schemas"]["PlacementInput"];
+export type PortCheckRequest = components["schemas"]["PortCheckRequest"];
+export type PortCheckResponse = components["schemas"]["PortCheckResponse"];
+export type PortConflict = components["schemas"]["PortConflict"];
+export type PortDTO = components["schemas"]["PortDTO"];
+export type PortListResponse = components["schemas"]["PortListResponse"];
+export type PortSpec = components["schemas"]["PortSpec"];
+export type PowerImpactDTO = components["schemas"]["PowerImpactDTO"];
+export type PowerLinkDTO = components["schemas"]["PowerLinkDTO"];
+export type PowerSourceDTO = components["schemas"]["PowerSourceDTO"];
+export type PowerSourcesDTO = components["schemas"]["PowerSourcesDTO"];
+export type ProjectDTO = components["schemas"]["ProjectDTO"];
+export type ProjectListResponse = components["schemas"]["ProjectListResponse"];
+export type RackDTO = components["schemas"]["RackDTO"];
+export type RackListResponse = components["schemas"]["RackListResponse"];
+export type RenameHostRequest = components["schemas"]["RenameHostRequest"];
+export type ResolvedAssetDTO = components["schemas"]["ResolvedAssetDTO"];
+export type ResourceSpec = components["schemas"]["ResourceSpec"];
+export type RuleDTO = components["schemas"]["RuleDTO"];
+export type RuleListResponse = components["schemas"]["RuleListResponse"];
+export type ScheduleDTO = components["schemas"]["ScheduleDTO"];
+export type ScheduleListResponse =
+	components["schemas"]["ScheduleListResponse"];
+export type ServiceDefDTO = components["schemas"]["ServiceDefDTO"];
+export type ServiceEdgeDTO = components["schemas"]["ServiceEdgeDTO"];
+export type ServiceListResponse = components["schemas"]["ServiceListResponse"];
+export type ServiceNodeDTO = components["schemas"]["ServiceNodeDTO"];
+export type ServiceSpec = components["schemas"]["ServiceSpec"];
+export type SetAcceptanceItemsRequest =
+	components["schemas"]["SetAcceptanceItemsRequest"];
+export type SetCanvasViewRequest =
+	components["schemas"]["SetCanvasViewRequest"];
+export type SetPositionRequest = components["schemas"]["SetPositionRequest"];
+export type SetRoleRequest = components["schemas"]["SetRoleRequest"];
+export type SignAcceptanceRequest =
+	components["schemas"]["SignAcceptanceRequest"];
+export type TailLogsResponse = components["schemas"]["TailLogsResponse"];
+export type ToggleRequest = components["schemas"]["ToggleRequest"];
+export type TopologyResponse = components["schemas"]["TopologyResponse"];
+export type TracePathDTO = components["schemas"]["TracePathDTO"];
+export type TransferAssetRequest =
+	components["schemas"]["TransferAssetRequest"];
+export type TunnelEgressVerifyDTO =
+	components["schemas"]["TunnelEgressVerifyDTO"];
+export type UpdateAcceptanceRequest =
+	components["schemas"]["UpdateAcceptanceRequest"];
+export type UpdateCableRequest = components["schemas"]["UpdateCableRequest"];
+export type UpdateCfAccountRequest =
+	components["schemas"]["UpdateCfAccountRequest"];
+export type UpdateComponentRequest =
+	components["schemas"]["UpdateComponentRequest"];
+export type UpdateDeviceRequest = components["schemas"]["UpdateDeviceRequest"];
+export type UpdateFeedRequest = components["schemas"]["UpdateFeedRequest"];
+export type UpdateLocationRequest =
+	components["schemas"]["UpdateLocationRequest"];
+export type UpdateOutletRequest = components["schemas"]["UpdateOutletRequest"];
+export type UpdatePduRequest = components["schemas"]["UpdatePduRequest"];
+export type UpdatePortRequest = components["schemas"]["UpdatePortRequest"];
+export type UpdateRackRequest = components["schemas"]["UpdateRackRequest"];
+export type UpsertDnsRecordRequest =
+	components["schemas"]["UpsertDnsRecordRequest"];
+export type UpsertEdgeRequest = components["schemas"]["UpsertEdgeRequest"];
+export type UpsertEnvGroupRequest =
+	components["schemas"]["UpsertEnvGroupRequest"];
+export type UpsertNodeRequest = components["schemas"]["UpsertNodeRequest"];
+export type UpsertProjectRequest =
+	components["schemas"]["UpsertProjectRequest"];
+export type UpsertServiceRequest =
+	components["schemas"]["UpsertServiceRequest"];
+export type VerifyAcceptanceItemInput =
+	components["schemas"]["VerifyAcceptanceItemInput"];
+export type VerifyAcceptanceRequest =
+	components["schemas"]["VerifyAcceptanceRequest"];
+export type VolumeSpec = components["schemas"]["VolumeSpec"];
+export type ZoneDTO = components["schemas"]["ZoneDTO"];
+export type ZoneListResponse = components["schemas"]["ZoneListResponse"];
+export type LoginResponse = authComponents["schemas"]["LoginResponse"];
+export type LogoutResponse = authComponents["schemas"]["LogoutResponse"];
+export type MinecraftAccountLinkResponse =
+	authComponents["schemas"]["MinecraftAccountLinkResponse"];
+export type MinecraftAccountResponse =
+	authComponents["schemas"]["MinecraftAccountResponse"];
+export type OAuthAuthorizationTokenResponse =
+	authComponents["schemas"]["OAuthAuthorizationTokenResponse"];
+export type OAuthCallbackRequest =
+	authComponents["schemas"]["OAuthCallbackRequest"];
+export type OAuthCaptchaChallengeResponse =
+	authComponents["schemas"]["OAuthCaptchaChallengeResponse"];
+export type OAuthCaptchaConfirmRequest =
+	authComponents["schemas"]["OAuthCaptchaConfirmRequest"];
+export type OAuthStartResponse =
+	authComponents["schemas"]["OAuthStartResponse"];
+export type OAuthTotpChallengeResponse =
+	authComponents["schemas"]["OAuthTotpChallengeResponse"];
+export type OAuthTotpConfirmRequest =
+	authComponents["schemas"]["OAuthTotpConfirmRequest"];
+export type PersonalAccessTokenCreateRequest =
+	authComponents["schemas"]["PersonalAccessTokenCreateRequest"];
+export type PersonalAccessTokenCreateResponse =
+	authComponents["schemas"]["PersonalAccessTokenCreateResponse"];
+export type PersonalAccessTokenItem =
+	authComponents["schemas"]["PersonalAccessTokenItem"];
+export type PersonalAccessTokenListResponse =
+	authComponents["schemas"]["PersonalAccessTokenListResponse"];
+export type RefreshTokenRequest =
+	authComponents["schemas"]["RefreshTokenRequest"];
+export type StatusResponse = authComponents["schemas"]["StatusResponse"];
+export type UserLogin = authComponents["schemas"]["UserLogin"];
+export type UserProfilePrivacy =
+	authComponents["schemas"]["UserProfilePrivacy"];
+export type UserPublic = authComponents["schemas"]["UserPublic"];
+export type UserRegister = authComponents["schemas"]["UserRegister"];
+export type UserStatus = authComponents["schemas"]["UserStatus"];
+export type UserTimeFormatPreference =
+	authComponents["schemas"]["UserTimeFormatPreference"];
+export type ControlAgentReleaseData = components["schemas"]["AgentReleaseDTO"];