@leavepulse/control-sdk 0.3.31

package/package.json

@@ -0,0 +1,28 @@
+{
+	"name": "@leavepulse/control-sdk",
+	"version": "0.3.31",
+	"description": "Generated resource SDK (@leavepulse/control-sdk).",
+	"type": "module",
+	"module": "index.ts",
+	"types": "index.ts",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/LeavePulse/leavepulse-sdk-control-ts.git"
+	},
+	"publishConfig": {
+		"registry": "https://registry.npmjs.org",
+		"access": "public"
+	},
+	"exports": {
+		".": "./index.ts",
+		"./types": "./types.ts",
+		"./models": "./models.ts",
+		"./auth-types": "./auth-types.ts"
+	},
+	"dependencies": {
+		"lossless-json": "^4.0.0",
+		"@bufbuild/protobuf": "^2.2.0"
+	},
+	"sideEffects": false,
+	"license": "UNLICENSED"
+}

package/procedures.ts

@@ -0,0 +1,451 @@
+// Generated from the LeavePulse contract. Do not edit.
+import type { ClientContext } from "./client";
+import { fetchCachedOrThrow } from "./runtime/etag-store";
+import type * as models from "./models";
+
+/** auth.oauth procedures. */
+export class AuthOauthNs {
+	constructor(private readonly ctx: ClientContext) {}
+
+	/** auth.oauth.captcha_confirm */
+	async captchaConfirm(
+		body: models.OAuthCaptchaConfirmRequest,
+	): Promise<models.LoginResponse | models.OAuthTotpChallengeResponse> {
+		return this.ctx.transport.request<
+			models.LoginResponse | models.OAuthTotpChallengeResponse
+		>({
+			method: "POST",
+			path: `/auth/oauth/captcha/confirm`,
+			body,
+			channel: "auth",
+		});
+	}
+
+	/** auth.oauth.totp_confirm */
+	async totpConfirm(
+		body: models.OAuthTotpConfirmRequest,
+	): Promise<models.LoginResponse> {
+		return this.ctx.transport.request<models.LoginResponse>({
+			method: "POST",
+			path: `/auth/oauth/totp/confirm`,
+			body,
+			channel: "auth",
+		});
+	}
+
+	/** auth.oauth.callback */
+	async callback(
+		provider: string,
+		body: models.OAuthCallbackRequest,
+	): Promise<
+		| models.LoginResponse
+		| models.OAuthCaptchaChallengeResponse
+		| models.OAuthTotpChallengeResponse
+		| models.StatusResponse
+		| models.MinecraftAccountLinkResponse
+	> {
+		return this.ctx.transport.request<
+			| models.LoginResponse
+			| models.OAuthCaptchaChallengeResponse
+			| models.OAuthTotpChallengeResponse
+			| models.StatusResponse
+			| models.MinecraftAccountLinkResponse
+		>({
+			method: "POST",
+			path: `/auth/oauth/${provider}/callback`,
+			body,
+			channel: "auth",
+		});
+	}
+
+	/** auth.oauth.start */
+	async start(
+		provider: string,
+		params?: { audience?: string },
+	): Promise<models.OAuthStartResponse> {
+		return fetchCachedOrThrow<models.OAuthStartResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/auth/oauth/${provider}/start`,
+				query: { audience: params?.audience },
+				channel: "auth",
+			},
+		);
+	}
+}
+
+/** auth.oauth2 procedures. */
+export class AuthOauth2Ns {
+	constructor(private readonly ctx: ClientContext) {}
+
+	/** auth.oauth2.authorize */
+	async authorize(params?: {
+		responseType?: string;
+		clientId?: string;
+		codeChallenge?: string;
+		redirectUri?: string;
+		scope?: string;
+		state?: string;
+		codeChallengeMethod?: string;
+	}): Promise<unknown> {
+		return fetchCachedOrThrow<unknown>(this.ctx.transport, this.ctx.etagStore, {
+			method: "GET",
+			path: `/auth/oauth/authorize`,
+			query: {
+				response_type: params?.responseType,
+				client_id: params?.clientId,
+				code_challenge: params?.codeChallenge,
+				redirect_uri: params?.redirectUri,
+				scope: params?.scope,
+				state: params?.state,
+				code_challenge_method: params?.codeChallengeMethod,
+			},
+			channel: "auth",
+		});
+	}
+
+	/** auth.oauth2.token */
+	async token(): Promise<models.OAuthAuthorizationTokenResponse> {
+		return this.ctx.transport.request<models.OAuthAuthorizationTokenResponse>({
+			method: "POST",
+			path: `/auth/oauth/token`,
+			channel: "auth",
+		});
+	}
+}
+
+/** auth.tokens procedures. */
+export class AuthTokensNs {
+	constructor(private readonly ctx: ClientContext) {}
+
+	/** auth.tokens.list */
+	async list(): Promise<models.PersonalAccessTokenListResponse> {
+		return fetchCachedOrThrow<models.PersonalAccessTokenListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/auth/pat-tokens`, channel: "auth" },
+		);
+	}
+
+	/** auth.tokens.create */
+	async create(
+		body: models.PersonalAccessTokenCreateRequest,
+	): Promise<models.PersonalAccessTokenCreateResponse> {
+		return this.ctx.transport.request<models.PersonalAccessTokenCreateResponse>(
+			{ method: "POST", path: `/auth/pat-tokens`, body, channel: "auth" },
+		);
+	}
+
+	/** auth.tokens.revoke */
+	async revoke(tokenId: number): Promise<models.StatusResponse> {
+		return this.ctx.transport.request<models.StatusResponse>({
+			method: "DELETE",
+			path: `/auth/pat-tokens/${tokenId}`,
+			channel: "auth",
+		});
+	}
+}
+
+/** auth.* procedures. */
+export class AuthNs {
+	readonly oauth: AuthOauthNs;
+	readonly oauth2: AuthOauth2Ns;
+	readonly tokens: AuthTokensNs;
+	constructor(private readonly ctx: ClientContext) {
+		this.oauth = new AuthOauthNs(ctx);
+		this.oauth2 = new AuthOauth2Ns(ctx);
+		this.tokens = new AuthTokensNs(ctx);
+	}
+
+	/** auth.login */
+	async login(body: models.UserLogin): Promise<models.LoginResponse> {
+		return this.ctx.transport.request<models.LoginResponse>({
+			method: "POST",
+			path: `/auth/login`,
+			body,
+			channel: "auth",
+		});
+	}
+
+	/** auth.logout */
+	async logout(): Promise<models.LogoutResponse> {
+		return this.ctx.transport.request<models.LogoutResponse>({
+			method: "POST",
+			path: `/auth/logout`,
+			channel: "auth",
+		});
+	}
+
+	/** auth.refresh */
+	async refresh(
+		body: models.RefreshTokenRequest,
+	): Promise<models.LoginResponse> {
+		return this.ctx.transport.request<models.LoginResponse>({
+			method: "POST",
+			path: `/auth/refresh`,
+			body,
+			channel: "auth",
+		});
+	}
+
+	/** auth.register */
+	async register(body: models.UserRegister): Promise<models.UserPublic> {
+		return this.ctx.transport.request<models.UserPublic>({
+			method: "POST",
+			path: `/auth/register`,
+			body,
+			channel: "auth",
+		});
+	}
+
+	/** auth.session */
+	async session(): Promise<models.LoginResponse> {
+		return this.ctx.transport.request<models.LoginResponse>({
+			method: "POST",
+			path: `/auth/session`,
+			channel: "auth",
+		});
+	}
+}
+
+/** control.cf.accounts procedures. */
+export class ControlCfAccountsNs {
+	constructor(private readonly ctx: ClientContext) {}
+
+	/** control.cf.accounts.dns_list */
+	async dnsList(
+		accountId: string,
+		params?: { zoneId?: string },
+	): Promise<models.DnsRecordListResponse> {
+		return fetchCachedOrThrow<models.DnsRecordListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/cf/accounts/${accountId}/dns`,
+				query: { zone_id: params?.zoneId },
+			},
+		);
+	}
+
+	/** control.cf.accounts.zones */
+	async zones(accountId: string): Promise<models.ZoneListResponse> {
+		return fetchCachedOrThrow<models.ZoneListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/cf/accounts/${accountId}/zones` },
+		);
+	}
+
+	/** control.cf.accounts.dns_create */
+	async dnsCreate(
+		accountId: string,
+		zoneId: string,
+		body: models.UpsertDnsRecordRequest,
+	): Promise<models.DnsRecordDTO> {
+		return this.ctx.transport.request<models.DnsRecordDTO>({
+			method: "POST",
+			path: `/v1/control/cf/accounts/${accountId}/zones/${zoneId}/dns`,
+			body,
+		});
+	}
+
+	/** control.cf.accounts.dns_delete */
+	async dnsDelete(
+		accountId: string,
+		zoneId: string,
+		recordId: string,
+	): Promise<unknown> {
+		return this.ctx.transport.request<unknown>({
+			method: "DELETE",
+			path: `/v1/control/cf/accounts/${accountId}/zones/${zoneId}/dns/${recordId}`,
+		});
+	}
+
+	/** control.cf.accounts.dns_update */
+	async dnsUpdate(
+		accountId: string,
+		zoneId: string,
+		recordId: string,
+		body: models.UpsertDnsRecordRequest,
+	): Promise<models.DnsRecordDTO> {
+		return this.ctx.transport.request<models.DnsRecordDTO>({
+			method: "PATCH",
+			path: `/v1/control/cf/accounts/${accountId}/zones/${zoneId}/dns/${recordId}`,
+			body,
+		});
+	}
+}
+
+/** control.dcim procedures. */
+export class ControlDcimNs {
+	constructor(private readonly ctx: ClientContext) {}
+
+	/** control.dcim.trace */
+	async trace(params?: {
+		cable?: string;
+		port?: string;
+	}): Promise<models.TracePathDTO> {
+		return fetchCachedOrThrow<models.TracePathDTO>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/dcim/power/trace`,
+				query: { cable: params?.cable, port: params?.port },
+			},
+		);
+	}
+}
+
+/** control.dcim.assets procedures. */
+export class ControlDcimAssetsNs {
+	constructor(private readonly ctx: ClientContext) {}
+
+	/** control.dcim.assets.history */
+	async history(params?: {
+		kind?: string;
+		assetId?: string;
+	}): Promise<models.OwnershipEventListResponse> {
+		return fetchCachedOrThrow<models.OwnershipEventListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/dcim/assets/history`,
+				query: { kind: params?.kind, asset_id: params?.assetId },
+			},
+		);
+	}
+
+	/** control.dcim.assets.resolve */
+	async resolve(params?: {
+		scanned?: string;
+		id?: string;
+		assetTag?: string;
+	}): Promise<models.ResolvedAssetDTO> {
+		return fetchCachedOrThrow<models.ResolvedAssetDTO>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/dcim/assets/resolve`,
+				query: {
+					scanned: params?.scanned,
+					id: params?.id,
+					asset_tag: params?.assetTag,
+				},
+			},
+		);
+	}
+
+	/** control.dcim.assets.transfer */
+	async transfer(
+		body: models.TransferAssetRequest,
+	): Promise<models.OwnershipEventDTO> {
+		return this.ctx.transport.request<models.OwnershipEventDTO>({
+			method: "POST",
+			path: `/v1/control/dcim/assets/transfer`,
+			body,
+		});
+	}
+}
+
+/** control.dcim.power procedures. */
+export class ControlDcimPowerNs {
+	constructor(private readonly ctx: ClientContext) {}
+
+	/** control.dcim.power.impact */
+	async impact(params?: {
+		feed?: string;
+		pdu?: string;
+		outlet?: string;
+	}): Promise<models.PowerImpactDTO> {
+		return fetchCachedOrThrow<models.PowerImpactDTO>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/dcim/power/impact`,
+				query: { feed: params?.feed, pdu: params?.pdu, outlet: params?.outlet },
+			},
+		);
+	}
+
+	/** control.dcim.power.sources */
+	async sources(params?: { device?: string }): Promise<models.PowerSourcesDTO> {
+		return fetchCachedOrThrow<models.PowerSourcesDTO>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/dcim/power/sources`,
+				query: { device: params?.device },
+			},
+		);
+	}
+}
+
+/** control.graph procedures. */
+export class ControlGraphNs {
+	constructor(private readonly ctx: ClientContext) {}
+
+	/** control.graph.topology */
+	async topology(params?: {
+		project?: string;
+		include?: string;
+	}): Promise<models.TopologyResponse> {
+		return fetchCachedOrThrow<models.TopologyResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/graph/topology`,
+				query: { project: params?.project, include: params?.include },
+			},
+		);
+	}
+}
+
+/** control.graph.canvas_view procedures. */
+export class ControlGraphCanvasViewNs {
+	constructor(private readonly ctx: ClientContext) {}
+
+	/** control.graph.canvas_view.get */
+	async get(): Promise<models.CanvasViewDTO> {
+		return fetchCachedOrThrow<models.CanvasViewDTO>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/graph/canvas-view` },
+		);
+	}
+
+	/** control.graph.canvas_view.set */
+	async set(body: models.SetCanvasViewRequest): Promise<models.CanvasViewDTO> {
+		return this.ctx.transport.request<models.CanvasViewDTO>({
+			method: "POST",
+			path: `/v1/control/graph/canvas-view`,
+			body,
+		});
+	}
+}
+
+/** control.* procedures. */
+export class ControlNs {
+	readonly cfAccounts: ControlCfAccountsNs;
+	readonly dcim: ControlDcimNs;
+	readonly dcimAssets: ControlDcimAssetsNs;
+	readonly dcimPower: ControlDcimPowerNs;
+	readonly graph: ControlGraphNs;
+	readonly graphCanvasView: ControlGraphCanvasViewNs;
+	constructor(ctx: ClientContext) {
+		this.cfAccounts = new ControlCfAccountsNs(ctx);
+		this.dcim = new ControlDcimNs(ctx);
+		this.dcimAssets = new ControlDcimAssetsNs(ctx);
+		this.dcimPower = new ControlDcimPowerNs(ctx);
+		this.graph = new ControlGraphNs(ctx);
+		this.graphCanvasView = new ControlGraphCanvasViewNs(ctx);
+	}
+}

package/resources/ControlAgentRelease.ts

@@ -0,0 +1,40 @@
+// Generated from the LeavePulse contract. Do not edit.
+import { Resource, extractId } from "../runtime/resource";
+import { fetchCachedOrThrow } from "../runtime/etag-store";
+import type { components } from "../types";
+import type * as models from "../models";
+import type { ClientContext } from "../client";
+
+type Data = components["schemas"]["AgentReleaseDTO"];
+
+export class ControlAgentRelease extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** Re-fetch this ControlAgentRelease and hydrate in place. */
+	async refresh(): Promise<this> {
+		const data = await fetchCachedOrThrow(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/agent-release` },
+		);
+		let hydrated = data as Record<string, unknown>;
+		const id = extractId(hydrated);
+		return this.ctx.cache.upsertAlias(
+			"ControlAgentRelease",
+			this.id,
+			id,
+			hydrated,
+			() => this,
+		) as this;
+	}
+
+	/** Load this ControlAgentRelease's data (alias of refresh). */
+	fetch(): Promise<this> {
+		return this.refresh();
+	}
+}

package/resources/ControlAlert.ts

@@ -0,0 +1,39 @@
+// 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>;
+
+export class ControlAlert extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.alerts.list */
+	async controlAlertsList(): Promise<models.AlertListResponse> {
+		return fetchCachedOrThrow<models.AlertListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/alerts` },
+		);
+	}
+
+	/** control.alerts.acknowledge */
+	async alertsAcknowledge(): Promise<models.AlertListResponse> {
+		return this.ctx.transport.request<models.AlertListResponse>({
+			method: "POST",
+			path: `/v1/control/alerts/acknowledge`,
+		});
+	}
+
+	/** Subscribe to `control.alerts` (private realtime). */
+	onAlerts(): TopicSubscription {
+		return new TopicSubscription(this.ctx.realtime, "control.alerts");
+	}
+}

package/resources/ControlCfAccount.ts

@@ -0,0 +1,82 @@
+// 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>;
+
+export class ControlCfAccount extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.cf.accounts.list */
+	async controlCfAccountsList(): Promise<models.CfAccountListResponse> {
+		return fetchCachedOrThrow<models.CfAccountListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/cf/accounts` },
+		);
+	}
+
+	/** control.cf.accounts.get */
+	async controlCfAccountsGet(): Promise<models.CfAccountDTO> {
+		return fetchCachedOrThrow<models.CfAccountDTO>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/cf/accounts/${this.id}` },
+		);
+	}
+
+	/** control.cf.accounts.create */
+	async cfAccountsCreate(
+		body: models.CreateCfAccountRequest,
+	): Promise<models.CfAccountDTO> {
+		return this.ctx.transport.request<models.CfAccountDTO>({
+			method: "POST",
+			path: `/v1/control/cf/accounts`,
+			body,
+		});
+	}
+
+	/** control.cf.accounts.delete */
+	async cfAccountsDelete(): Promise<this> {
+		await this.ctx.transport.request({
+			method: "DELETE",
+			path: `/v1/control/cf/accounts/${this.id}`,
+		});
+		return this;
+	}
+
+	/** control.cf.accounts.update */
+	async cfAccountsUpdate(
+		body: models.UpdateCfAccountRequest,
+	): Promise<models.CfAccountDTO> {
+		return this.ctx.transport.request<models.CfAccountDTO>({
+			method: "PATCH",
+			path: `/v1/control/cf/accounts/${this.id}`,
+			body,
+		});
+	}
+
+	/** control.cf.accounts.login */
+	async cfAccountsLogin(params?: {
+		force?: boolean;
+	}): Promise<models.CfAccountDTO> {
+		return this.ctx.transport.request<models.CfAccountDTO>({
+			method: "POST",
+			path: `/v1/control/cf/accounts/${this.id}/login`,
+			query: { force: params?.force },
+		});
+	}
+
+	/** Subscribe to `control.cf.accounts` (private realtime). */
+	onAccounts(): TopicSubscription {
+		return new TopicSubscription(this.ctx.realtime, "control.cf.accounts");
+	}
+}