@leavepulse/control-sdk 0.3.31

package/resources/ControlDcimRack.ts

@@ -0,0 +1,61 @@
+// Generated from the LeavePulse contract. Do not edit.
+import { Resource } from "../runtime/resource";
+import { fetchCachedOrThrow } from "../runtime/etag-store";
+import type * as models from "../models";
+import type { ClientContext } from "../client";
+
+type Data = { id: string | number } & Record<string, unknown>;
+
+export class ControlDcimRack extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.dcim.racks.list */
+	async controlDcimRacksList(params?: {
+		location?: string;
+	}): Promise<models.RackListResponse> {
+		return fetchCachedOrThrow<models.RackListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/dcim/racks`,
+				query: { location: params?.location },
+			},
+		);
+	}
+
+	/** control.dcim.racks.create */
+	async dcimRacksCreate(
+		body: models.CreateRackRequest,
+	): Promise<models.RackDTO> {
+		return this.ctx.transport.request<models.RackDTO>({
+			method: "POST",
+			path: `/v1/control/dcim/racks`,
+			body,
+		});
+	}
+
+	/** control.dcim.racks.delete */
+	async dcimRacksDelete(): Promise<models.DeleteResultDTO> {
+		return this.ctx.transport.request<models.DeleteResultDTO>({
+			method: "DELETE",
+			path: `/v1/control/dcim/racks/${this.id}`,
+		});
+	}
+
+	/** control.dcim.racks.update */
+	async dcimRacksUpdate(
+		body: models.UpdateRackRequest,
+	): Promise<models.RackDTO> {
+		return this.ctx.transport.request<models.RackDTO>({
+			method: "PATCH",
+			path: `/v1/control/dcim/racks/${this.id}`,
+			body,
+		});
+	}
+}

package/resources/ControlEdge.ts

@@ -0,0 +1,43 @@
+// Generated from the LeavePulse contract. Do not edit.
+import { Resource } from "../runtime/resource";
+import type * as models from "../models";
+import type { ClientContext } from "../client";
+
+type Data = { id: string | number } & Record<string, unknown>;
+
+export class ControlEdge extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.graph.edges.upsert */
+	async graphEdgesUpsert(
+		body: models.UpsertEdgeRequest,
+	): Promise<models.EdgeDTO> {
+		return this.ctx.transport.request<models.EdgeDTO>({
+			method: "POST",
+			path: `/v1/control/graph/edges`,
+			body,
+		});
+	}
+
+	/** control.graph.edges.delete */
+	async graphEdgesDelete(): Promise<this> {
+		await this.ctx.transport.request({
+			method: "DELETE",
+			path: `/v1/control/graph/edges/${this.id}`,
+		});
+		return this;
+	}
+
+	/** control.graph.edges.verify_egress */
+	async graphEdgesVerifyEgress(): Promise<models.TunnelEgressVerifyDTO> {
+		return this.ctx.transport.request<models.TunnelEgressVerifyDTO>({
+			method: "POST",
+			path: `/v1/control/graph/edges/${this.id}/verify-egress`,
+		});
+	}
+}

package/resources/ControlEnrollToken.ts

@@ -0,0 +1,45 @@
+// Generated from the LeavePulse contract. Do not edit.
+import { Resource } from "../runtime/resource";
+import { fetchCachedOrThrow } from "../runtime/etag-store";
+import type * as models from "../models";
+import type { ClientContext } from "../client";
+
+type Data = { id: string | number } & Record<string, unknown>;
+
+export class ControlEnrollToken extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.enroll_tokens.list */
+	async controlEnrollTokensList(): Promise<models.EnrollTokenListResponse> {
+		return fetchCachedOrThrow<models.EnrollTokenListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/enroll-tokens` },
+		);
+	}
+
+	/** control.enroll_tokens.create */
+	async enrollTokensCreate(
+		body: models.CreateEnrollTokenRequest,
+	): Promise<models.CreateEnrollTokenResponse> {
+		return this.ctx.transport.request<models.CreateEnrollTokenResponse>({
+			method: "POST",
+			path: `/v1/control/enroll-tokens`,
+			body,
+		});
+	}
+
+	/** control.enroll_tokens.revoke */
+	async enrollTokensRevoke(): Promise<this> {
+		await this.ctx.transport.request({
+			method: "DELETE",
+			path: `/v1/control/enroll-tokens/${this.id}`,
+		});
+		return this;
+	}
+}

package/resources/ControlEnvGroup.ts

@@ -0,0 +1,60 @@
+// Generated from the LeavePulse contract. Do not edit.
+import { Resource } from "../runtime/resource";
+import { fetchCachedOrThrow } from "../runtime/etag-store";
+import type * as models from "../models";
+import type { ClientContext } from "../client";
+
+type Data = { id: string | number } & Record<string, unknown>;
+
+export class ControlEnvGroup extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.env_groups.list */
+	async controlEnvGroupsList(): Promise<models.EnvGroupListResponse> {
+		return fetchCachedOrThrow<models.EnvGroupListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/env-groups` },
+		);
+	}
+
+	/** control.env_groups.get */
+	async controlEnvGroupsGet(params?: {
+		reveal?: boolean;
+	}): Promise<models.EnvGroupDTO> {
+		return fetchCachedOrThrow<models.EnvGroupDTO>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/env-groups/${this.id}`,
+				query: { reveal: params?.reveal },
+			},
+		);
+	}
+
+	/** control.env_groups.delete */
+	async envGroupsDelete(): Promise<this> {
+		await this.ctx.transport.request({
+			method: "DELETE",
+			path: `/v1/control/env-groups/${this.id}`,
+		});
+		return this;
+	}
+
+	/** control.env_groups.upsert */
+	async envGroupsUpsert(
+		body: models.UpsertEnvGroupRequest,
+	): Promise<models.EnvGroupDTO> {
+		return this.ctx.transport.request<models.EnvGroupDTO>({
+			method: "PUT",
+			path: `/v1/control/env-groups/${this.id}`,
+			body,
+		});
+	}
+}

package/resources/ControlHost.ts

@@ -0,0 +1,184 @@
+// Generated from the LeavePulse contract. Do not edit.
+import { Resource } from "../runtime/resource";
+import { TopicSubscription } from "../runtime/realtime";
+import { fetchCachedOrThrow } from "../runtime/etag-store";
+import type * as models from "../models";
+import type { ClientContext } from "../client";
+
+type Data = { id: string | number } & Record<string, unknown> & {
+		container?: string | number;
+	};
+
+export class ControlHost extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.hosts.list */
+	async controlHostsList(params?: {
+		tag?: string;
+	}): Promise<models.HostListResponse> {
+		return fetchCachedOrThrow<models.HostListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/hosts`, query: { tag: params?.tag } },
+		);
+	}
+
+	/** control.hosts.get */
+	async controlHostsGet(): Promise<models.HostDTO> {
+		return fetchCachedOrThrow<models.HostDTO>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/hosts/${this.id}` },
+		);
+	}
+
+	/** control.hosts.container_inspect */
+	async controlHostsContainerInspect(
+		container: string,
+	): Promise<models.InspectResponse> {
+		return fetchCachedOrThrow<models.InspectResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/hosts/${this.id}/containers/${container}/inspect`,
+			},
+		);
+	}
+
+	/** control.hosts.container_logs */
+	async controlHostsContainerLogs(
+		container: string,
+		params?: { lines?: number; before?: number },
+	): Promise<models.TailLogsResponse> {
+		return fetchCachedOrThrow<models.TailLogsResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/hosts/${this.id}/containers/${container}/logs`,
+				query: { lines: params?.lines, before: params?.before },
+			},
+		);
+	}
+
+	/** control.hosts.docker_df */
+	async controlHostsDockerDf(): Promise<models.DockerDfResponse> {
+		return fetchCachedOrThrow<models.DockerDfResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/hosts/${this.id}/docker/df` },
+		);
+	}
+
+	/** control.hosts.firewall_rules */
+	async controlHostsFirewallRules(): Promise<models.FirewallRulesResponse> {
+		return fetchCachedOrThrow<models.FirewallRulesResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/hosts/${this.id}/firewall/rules` },
+		);
+	}
+
+	/** control.hosts.rename */
+	async hostsRename(body: models.RenameHostRequest): Promise<models.HostDTO> {
+		return this.ctx.transport.request<models.HostDTO>({
+			method: "PATCH",
+			path: `/v1/control/hosts/${this.id}`,
+			body,
+		});
+	}
+
+	/** control.hosts.container_action */
+	async hostsContainerAction(
+		container: string,
+		body: models.ContainerActionRequest,
+	): Promise<models.ContainerActionResponse> {
+		return this.ctx.transport.request<models.ContainerActionResponse>({
+			method: "POST",
+			path: `/v1/control/hosts/${this.id}/containers/${container}/action`,
+			body,
+		});
+	}
+
+	/** control.hosts.decommission */
+	async hostsDecommission(
+		body: models.DecommissionRequest,
+	): Promise<models.DecommissionResponse> {
+		return this.ctx.transport.request<models.DecommissionResponse>({
+			method: "POST",
+			path: `/v1/control/hosts/${this.id}/decommission`,
+			body,
+		});
+	}
+
+	/** control.hosts.docker_prune */
+	async hostsDockerPrune(
+		body: models.DockerPruneRequest,
+	): Promise<models.DockerPruneResponse> {
+		return this.ctx.transport.request<models.DockerPruneResponse>({
+			method: "POST",
+			path: `/v1/control/hosts/${this.id}/docker/prune`,
+			body,
+		});
+	}
+
+	/** control.hosts.install_exporter */
+	async hostsInstallExporter(
+		body: models.InstallExporterRequest,
+	): Promise<models.InstallExporterResponse> {
+		return this.ctx.transport.request<models.InstallExporterResponse>({
+			method: "POST",
+			path: `/v1/control/hosts/${this.id}/exporters`,
+			body,
+		});
+	}
+
+	/** control.hosts.firewall_block */
+	async hostsFirewallBlock(
+		body: models.FirewallBlockRequest,
+	): Promise<models.FirewallActionResponse> {
+		return this.ctx.transport.request<models.FirewallActionResponse>({
+			method: "POST",
+			path: `/v1/control/hosts/${this.id}/firewall/block`,
+			body,
+		});
+	}
+
+	/** control.hosts.firewall_unblock */
+	async hostsFirewallUnblock(
+		body: models.FirewallBlockRequest,
+	): Promise<models.FirewallActionResponse> {
+		return this.ctx.transport.request<models.FirewallActionResponse>({
+			method: "POST",
+			path: `/v1/control/hosts/${this.id}/firewall/unblock`,
+			body,
+		});
+	}
+
+	/** Subscribe to `control.logs.{host_id}.{container}` (private realtime). */
+	onLogs(): TopicSubscription {
+		return new TopicSubscription(
+			this.ctx.realtime,
+			`control.logs.${this.id}.${this.id}`,
+		);
+	}
+
+	/** Subscribe to `control.metrics.{host_id}` (private realtime). */
+	onMetrics(): TopicSubscription {
+		return new TopicSubscription(
+			this.ctx.realtime,
+			`control.metrics.${this.id}`,
+		);
+	}
+
+	/** Subscribe to `control.hosts` (private realtime). */
+	onHosts(): TopicSubscription {
+		return new TopicSubscription(this.ctx.realtime, "control.hosts");
+	}
+}

package/resources/ControlNode.ts

@@ -0,0 +1,48 @@
+// Generated from the LeavePulse contract. Do not edit.
+import { Resource } from "../runtime/resource";
+import type * as models from "../models";
+import type { ClientContext } from "../client";
+
+type Data = { id: string | number } & Record<string, unknown>;
+
+export class ControlNode extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.graph.nodes.role */
+	async graphNodesRole(
+		hostId: string,
+		body: models.SetRoleRequest,
+	): Promise<models.NodeDTO> {
+		return this.ctx.transport.request<models.NodeDTO>({
+			method: "POST",
+			path: `/v1/control/graph/hosts/${hostId}/role`,
+			body,
+		});
+	}
+
+	/** control.graph.nodes.upsert */
+	async graphNodesUpsert(
+		body: models.UpsertNodeRequest,
+	): Promise<models.NodeDTO> {
+		return this.ctx.transport.request<models.NodeDTO>({
+			method: "POST",
+			path: `/v1/control/graph/nodes`,
+			body,
+		});
+	}
+
+	/** control.graph.nodes.position */
+	async graphNodesPosition(body: models.SetPositionRequest): Promise<this> {
+		await this.ctx.transport.request({
+			method: "POST",
+			path: `/v1/control/graph/nodes/${this.id}/position`,
+			body,
+		});
+		return this;
+	}
+}

package/resources/ControlProject.ts

@@ -0,0 +1,36 @@
+// Generated from the LeavePulse contract. Do not edit.
+import { Resource } from "../runtime/resource";
+import { fetchCachedOrThrow } from "../runtime/etag-store";
+import type * as models from "../models";
+import type { ClientContext } from "../client";
+
+type Data = { id: string | number } & Record<string, unknown>;
+
+export class ControlProject extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.graph.projects.list */
+	async controlGraphProjectsList(): Promise<models.ProjectListResponse> {
+		return fetchCachedOrThrow<models.ProjectListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/graph/projects` },
+		);
+	}
+
+	/** control.graph.projects.upsert */
+	async graphProjectsUpsert(
+		body: models.UpsertProjectRequest,
+	): Promise<models.ProjectDTO> {
+		return this.ctx.transport.request<models.ProjectDTO>({
+			method: "POST",
+			path: `/v1/control/graph/projects`,
+			body,
+		});
+	}
+}

package/resources/ControlRule.ts

@@ -0,0 +1,56 @@
+// Generated from the LeavePulse contract. Do not edit.
+import { Resource } from "../runtime/resource";
+import { fetchCachedOrThrow } from "../runtime/etag-store";
+import type * as models from "../models";
+import type { ClientContext } from "../client";
+
+type Data = { id: string | number } & Record<string, unknown>;
+
+export class ControlRule extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.automation.list_rules */
+	async controlAutomationListRules(): Promise<models.RuleListResponse> {
+		return fetchCachedOrThrow<models.RuleListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/automation/rules` },
+		);
+	}
+
+	/** control.automation.create_rule */
+	async automationCreateRule(
+		body: models.CreateRuleRequest,
+	): Promise<models.RuleDTO> {
+		return this.ctx.transport.request<models.RuleDTO>({
+			method: "POST",
+			path: `/v1/control/automation/rules`,
+			body,
+		});
+	}
+
+	/** control.automation.delete_rule */
+	async automationDeleteRule(): Promise<this> {
+		await this.ctx.transport.request({
+			method: "DELETE",
+			path: `/v1/control/automation/rules/${this.id}`,
+		});
+		return this;
+	}
+
+	/** control.automation.toggle_rule */
+	async automationToggleRule(
+		body: models.ToggleRequest,
+	): Promise<models.RuleDTO> {
+		return this.ctx.transport.request<models.RuleDTO>({
+			method: "PATCH",
+			path: `/v1/control/automation/rules/${this.id}`,
+			body,
+		});
+	}
+}

package/resources/ControlSchedule.ts

@@ -0,0 +1,56 @@
+// Generated from the LeavePulse contract. Do not edit.
+import { Resource } from "../runtime/resource";
+import { fetchCachedOrThrow } from "../runtime/etag-store";
+import type * as models from "../models";
+import type { ClientContext } from "../client";
+
+type Data = { id: string | number } & Record<string, unknown>;
+
+export class ControlSchedule extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.automation.list_schedules */
+	async controlAutomationListSchedules(): Promise<models.ScheduleListResponse> {
+		return fetchCachedOrThrow<models.ScheduleListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/automation/schedules` },
+		);
+	}
+
+	/** control.automation.create_schedule */
+	async automationCreateSchedule(
+		body: models.CreateScheduleRequest,
+	): Promise<models.ScheduleDTO> {
+		return this.ctx.transport.request<models.ScheduleDTO>({
+			method: "POST",
+			path: `/v1/control/automation/schedules`,
+			body,
+		});
+	}
+
+	/** control.automation.delete_schedule */
+	async automationDeleteSchedule(): Promise<this> {
+		await this.ctx.transport.request({
+			method: "DELETE",
+			path: `/v1/control/automation/schedules/${this.id}`,
+		});
+		return this;
+	}
+
+	/** control.automation.toggle_schedule */
+	async automationToggleSchedule(
+		body: models.ToggleRequest,
+	): Promise<models.ScheduleDTO> {
+		return this.ctx.transport.request<models.ScheduleDTO>({
+			method: "PATCH",
+			path: `/v1/control/automation/schedules/${this.id}`,
+			body,
+		});
+	}
+}

package/resources/ControlService.ts

@@ -0,0 +1,101 @@
+// Generated from the LeavePulse contract. Do not edit.
+import { Resource } from "../runtime/resource";
+import { fetchCachedOrThrow } from "../runtime/etag-store";
+import type * as models from "../models";
+import type { ClientContext } from "../client";
+
+type Data = { id: string | number } & Record<string, unknown>;
+
+export class ControlService extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.services.list */
+	async controlServicesList(): Promise<models.ServiceListResponse> {
+		return fetchCachedOrThrow<models.ServiceListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/services` },
+		);
+	}
+
+	/** control.services.get */
+	async controlServicesGet(params?: {
+		reveal?: boolean;
+	}): Promise<models.ServiceDefDTO> {
+		return fetchCachedOrThrow<models.ServiceDefDTO>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/services/${this.id}`,
+				query: { reveal: params?.reveal },
+			},
+		);
+	}
+
+	/** control.services.delete */
+	async servicesDelete(): Promise<this> {
+		await this.ctx.transport.request({
+			method: "DELETE",
+			path: `/v1/control/services/${this.id}`,
+		});
+		return this;
+	}
+
+	/** control.services.upsert */
+	async servicesUpsert(
+		body: models.UpsertServiceRequest,
+	): Promise<models.ServiceDefDTO> {
+		return this.ctx.transport.request<models.ServiceDefDTO>({
+			method: "PUT",
+			path: `/v1/control/services/${this.id}`,
+			body,
+		});
+	}
+
+	/** control.services.check_ports */
+	async servicesCheckPorts(
+		body: models.PortCheckRequest,
+	): Promise<models.PortCheckResponse> {
+		return this.ctx.transport.request<models.PortCheckResponse>({
+			method: "POST",
+			path: `/v1/control/services/${this.id}/check-ports`,
+			body,
+		});
+	}
+
+	/** control.services.deploy */
+	async servicesDeploy(
+		body: models.DeployRequest,
+	): Promise<models.DeploymentDTO> {
+		return this.ctx.transport.request<models.DeploymentDTO>({
+			method: "POST",
+			path: `/v1/control/services/${this.id}/deploy`,
+			body,
+		});
+	}
+
+	/** control.services.deployments */
+	async servicesDeployments(): Promise<models.DeploymentListResponse> {
+		return this.ctx.transport.request<models.DeploymentListResponse>({
+			method: "GET",
+			path: `/v1/control/services/${this.id}/deployments`,
+		});
+	}
+
+	/** control.services.preview_compose */
+	async servicesPreviewCompose(
+		body: models.ServiceSpec,
+	): Promise<models.ComposePreviewDTO> {
+		return this.ctx.transport.request<models.ComposePreviewDTO>({
+			method: "POST",
+			path: `/v1/control/services/${this.id}/preview-compose`,
+			body,
+		});
+	}
+}