@leavepulse/control-sdk 0.3.54 → 0.3.55

package/client.ts

@@ -14,6 +14,7 @@ import { ControlDcimAcceptance } from "./resources/ControlDcimAcceptance";
 import { ControlDcimCable } from "./resources/ControlDcimCable";
 import { ControlDcimComponent } from "./resources/ControlDcimComponent";
 import { ControlDcimComponentType } from "./resources/ControlDcimComponentType";
+import { ControlDcimConnectorType } from "./resources/ControlDcimConnectorType";
 import { ControlDcimDevice } from "./resources/ControlDcimDevice";
 import { ControlDcimDeviceType } from "./resources/ControlDcimDeviceType";
 import { ControlDcimFeed } from "./resources/ControlDcimFeed";
@@ -23,6 +24,9 @@ import { ControlDcimOutlet } from "./resources/ControlDcimOutlet";
 import { ControlDcimPdu } from "./resources/ControlDcimPdu";
 import { ControlDcimPhoto } from "./resources/ControlDcimPhoto";
 import { ControlDcimPort } from "./resources/ControlDcimPort";
+import { ControlDcimPowerConnection } from "./resources/ControlDcimPowerConnection";
+import { ControlDcimPowerGroup } from "./resources/ControlDcimPowerGroup";
+import { ControlDcimPowerInterface } from "./resources/ControlDcimPowerInterface";
 import { ControlDcimPowerLink } from "./resources/ControlDcimPowerLink";
 import { ControlDcimRack } from "./resources/ControlDcimRack";
 import { ControlDcimStorageNode } from "./resources/ControlDcimStorageNode";
@@ -142,6 +146,24 @@ export class LeavePulse {
 		) as ControlDcimComponentType;
 	}
 
+	controldcimconnectortype(
+		connectorTypeId: string,
+		matesWithId: string,
+	): ControlDcimConnectorType {
+		return this.ctx.cache.ensure(
+			"ControlDcimConnectorType",
+			matesWithId,
+			() =>
+				new ControlDcimConnectorType(
+					{
+						connector_type_id: connectorTypeId,
+						mates_with_id: matesWithId,
+					} as never,
+					this.ctx,
+				),
+		) as ControlDcimConnectorType;
+	}
+
 	controldcimdevice(id: string): ControlDcimDevice {
 		return this.ctx.cache.ensure(
 			"ControlDcimDevice",
@@ -214,6 +236,30 @@ export class LeavePulse {
 		) as ControlDcimPort;
 	}
 
+	controldcimpowerconnection(id: string): ControlDcimPowerConnection {
+		return this.ctx.cache.ensure(
+			"ControlDcimPowerConnection",
+			id,
+			() => new ControlDcimPowerConnection({ id } as never, this.ctx),
+		) as ControlDcimPowerConnection;
+	}
+
+	controldcimpowergroup(id: string): ControlDcimPowerGroup {
+		return this.ctx.cache.ensure(
+			"ControlDcimPowerGroup",
+			id,
+			() => new ControlDcimPowerGroup({ id } as never, this.ctx),
+		) as ControlDcimPowerGroup;
+	}
+
+	controldcimpowerinterface(id: string): ControlDcimPowerInterface {
+		return this.ctx.cache.ensure(
+			"ControlDcimPowerInterface",
+			id,
+			() => new ControlDcimPowerInterface({ id } as never, this.ctx),
+		) as ControlDcimPowerInterface;
+	}
+
 	controldcimpowerlink(id: string): ControlDcimPowerLink {
 		return this.ctx.cache.ensure(
 			"ControlDcimPowerLink",
@@ -335,6 +381,8 @@ export class LeavePulse {
 				new ControlDcimComponent(d as never, this.ctx),
 			ControlDcimComponentType: (d) =>
 				new ControlDcimComponentType(d as never, this.ctx),
+			ControlDcimConnectorType: (d) =>
+				new ControlDcimConnectorType(d as never, this.ctx),
 			ControlDcimDevice: (d) => new ControlDcimDevice(d as never, this.ctx),
 			ControlDcimDeviceType: (d) =>
 				new ControlDcimDeviceType(d as never, this.ctx),
@@ -346,6 +394,12 @@ export class LeavePulse {
 			ControlDcimPdu: (d) => new ControlDcimPdu(d as never, this.ctx),
 			ControlDcimPhoto: (d) => new ControlDcimPhoto(d as never, this.ctx),
 			ControlDcimPort: (d) => new ControlDcimPort(d as never, this.ctx),
+			ControlDcimPowerConnection: (d) =>
+				new ControlDcimPowerConnection(d as never, this.ctx),
+			ControlDcimPowerGroup: (d) =>
+				new ControlDcimPowerGroup(d as never, this.ctx),
+			ControlDcimPowerInterface: (d) =>
+				new ControlDcimPowerInterface(d as never, this.ctx),
 			ControlDcimPowerLink: (d) =>
 				new ControlDcimPowerLink(d as never, this.ctx),
 			ControlDcimRack: (d) => new ControlDcimRack(d as never, this.ctx),

package/index.ts

@@ -10,6 +10,7 @@ export { ControlDcimAcceptance } from "./resources/ControlDcimAcceptance";
 export { ControlDcimCable } from "./resources/ControlDcimCable";
 export { ControlDcimComponent } from "./resources/ControlDcimComponent";
 export { ControlDcimComponentType } from "./resources/ControlDcimComponentType";
+export { ControlDcimConnectorType } from "./resources/ControlDcimConnectorType";
 export { ControlDcimDevice } from "./resources/ControlDcimDevice";
 export { ControlDcimDeviceType } from "./resources/ControlDcimDeviceType";
 export { ControlDcimFeed } from "./resources/ControlDcimFeed";
@@ -19,6 +20,9 @@ export { ControlDcimOutlet } from "./resources/ControlDcimOutlet";
 export { ControlDcimPdu } from "./resources/ControlDcimPdu";
 export { ControlDcimPhoto } from "./resources/ControlDcimPhoto";
 export { ControlDcimPort } from "./resources/ControlDcimPort";
+export { ControlDcimPowerConnection } from "./resources/ControlDcimPowerConnection";
+export { ControlDcimPowerGroup } from "./resources/ControlDcimPowerGroup";
+export { ControlDcimPowerInterface } from "./resources/ControlDcimPowerInterface";
 export { ControlDcimPowerLink } from "./resources/ControlDcimPowerLink";
 export { ControlDcimRack } from "./resources/ControlDcimRack";
 export { ControlDcimStorageNode } from "./resources/ControlDcimStorageNode";

package/models.ts

@@ -36,7 +36,14 @@ export type ComponentTypeListResponse =
 	components["schemas"]["ComponentTypeListResponse"];
 export type ComposePreviewDTO = components["schemas"]["ComposePreviewDTO"];
 export type ConfigFileDTO = components["schemas"]["ConfigFileDTO"];
+export type ConnectPowerInterfaceRequest =
+	components["schemas"]["ConnectPowerInterfaceRequest"];
 export type ConnectPowerRequest = components["schemas"]["ConnectPowerRequest"];
+export type ConnectPowerResponse =
+	components["schemas"]["ConnectPowerResponse"];
+export type ConnectorTypeDTO = components["schemas"]["ConnectorTypeDTO"];
+export type ConnectorTypeListResponse =
+	components["schemas"]["ConnectorTypeListResponse"];
 export type ContainerActionRequest =
 	components["schemas"]["ContainerActionRequest"];
 export type ContainerActionResponse =
@@ -84,6 +91,8 @@ export type DeviceTypeListResponse =
 	components["schemas"]["DeviceTypeListResponse"];
 export type DeviceTypePortDTO = components["schemas"]["DeviceTypePortDTO"];
 export type DeviceTypePortInput = components["schemas"]["DeviceTypePortInput"];
+export type DisconnectPowerRequest =
+	components["schemas"]["DisconnectPowerRequest"];
 export type DiskCategory = components["schemas"]["DiskCategory"];
 export type DiskUsageDTO = components["schemas"]["DiskUsageDTO"];
 export type DisputeAcceptanceRequest =
@@ -163,7 +172,20 @@ 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 PowerCompatibilityResponse =
+	components["schemas"]["PowerCompatibilityResponse"];
+export type PowerConnectionDTO = components["schemas"]["PowerConnectionDTO"];
+export type PowerConnectionListResponse =
+	components["schemas"]["PowerConnectionListResponse"];
+export type PowerFindingDTO = components["schemas"]["PowerFindingDTO"];
+export type PowerGroupDTO = components["schemas"]["PowerGroupDTO"];
+export type PowerGroupListResponse =
+	components["schemas"]["PowerGroupListResponse"];
 export type PowerImpactDTO = components["schemas"]["PowerImpactDTO"];
+export type PowerInterfaceDTO = components["schemas"]["PowerInterfaceDTO"];
+export type PowerInterfaceInput = components["schemas"]["PowerInterfaceInput"];
+export type PowerInterfaceListResponse =
+	components["schemas"]["PowerInterfaceListResponse"];
 export type PowerLinkDTO = components["schemas"]["PowerLinkDTO"];
 export type PowerSourceDTO = components["schemas"]["PowerSourceDTO"];
 export type PowerSourcesDTO = components["schemas"]["PowerSourcesDTO"];
@@ -179,6 +201,8 @@ export type RuleListResponse = components["schemas"]["RuleListResponse"];
 export type ScheduleDTO = components["schemas"]["ScheduleDTO"];
 export type ScheduleListResponse =
 	components["schemas"]["ScheduleListResponse"];
+export type SeedConnectorTypesResponse =
+	components["schemas"]["SeedConnectorTypesResponse"];
 export type SeriesDTO = components["schemas"]["SeriesDTO"];
 export type ServiceDefDTO = components["schemas"]["ServiceDefDTO"];
 export type ServiceEdgeDTO = components["schemas"]["ServiceEdgeDTO"];
@@ -189,12 +213,16 @@ export type SetAcceptanceItemsRequest =
 	components["schemas"]["SetAcceptanceItemsRequest"];
 export type SetCanvasViewRequest =
 	components["schemas"]["SetCanvasViewRequest"];
+export type SetConnectorMatingRequest =
+	components["schemas"]["SetConnectorMatingRequest"];
 export type SetDeviceTypePortsRequest =
 	components["schemas"]["SetDeviceTypePortsRequest"];
 export type SetEnvVarRequest = components["schemas"]["SetEnvVarRequest"];
 export type SetHostEndpointRequest =
 	components["schemas"]["SetHostEndpointRequest"];
 export type SetPositionRequest = components["schemas"]["SetPositionRequest"];
+export type SetPowerInterfacesRequest =
+	components["schemas"]["SetPowerInterfacesRequest"];
 export type SetRoleRequest = components["schemas"]["SetRoleRequest"];
 export type SignAcceptanceRequest =
 	components["schemas"]["SignAcceptanceRequest"];
@@ -231,6 +259,8 @@ export type UploadImageRequest = components["schemas"]["UploadImageRequest"];
 export type UploadImageResponse = components["schemas"]["UploadImageResponse"];
 export type UpsertComponentTypeRequest =
 	components["schemas"]["UpsertComponentTypeRequest"];
+export type UpsertConnectorTypeRequest =
+	components["schemas"]["UpsertConnectorTypeRequest"];
 export type UpsertDeviceTypeRequest =
 	components["schemas"]["UpsertDeviceTypeRequest"];
 export type UpsertDnsRecordRequest =
@@ -241,6 +271,10 @@ export type UpsertEnvGroupRequest =
 export type UpsertManufacturerRequest =
 	components["schemas"]["UpsertManufacturerRequest"];
 export type UpsertNodeRequest = components["schemas"]["UpsertNodeRequest"];
+export type UpsertPowerGroupRequest =
+	components["schemas"]["UpsertPowerGroupRequest"];
+export type UpsertPowerInterfaceRequest =
+	components["schemas"]["UpsertPowerInterfaceRequest"];
 export type UpsertProjectRequest =
 	components["schemas"]["UpsertProjectRequest"];
 export type UpsertServiceRequest =

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@leavepulse/control-sdk",
-	"version": "0.3.54",
+	"version": "0.3.55",
 	"description": "Generated resource SDK (@leavepulse/control-sdk).",
 	"type": "module",
 	"module": "index.ts",

package/resources/ControlDcimConnectorType.ts

@@ -0,0 +1,90 @@
+// 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> & {
+		connector_type_id?: string | number;
+	};
+
+export class ControlDcimConnectorType extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.dcim.catalog.connectors.list */
+	async controlDcimCatalogConnectorsList(params?: {
+		family?: string;
+		search?: string;
+		limit?: number;
+	}): Promise<models.ConnectorTypeListResponse> {
+		return fetchCachedOrThrow<models.ConnectorTypeListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/dcim/catalog/connectors`,
+				query: {
+					family: params?.family,
+					search: params?.search,
+					limit: params?.limit,
+				},
+			},
+		);
+	}
+
+	/** control.dcim.catalog.connectors.upsert */
+	async dcimCatalogConnectorsUpsert(
+		body: models.UpsertConnectorTypeRequest,
+	): Promise<models.ConnectorTypeDTO> {
+		return this.ctx.transport.request<models.ConnectorTypeDTO>({
+			method: "POST",
+			path: `/v1/control/dcim/catalog/connectors`,
+			body,
+		});
+	}
+
+	/** control.dcim.catalog.connectors.seed */
+	async dcimCatalogConnectorsSeed(): Promise<models.SeedConnectorTypesResponse> {
+		return this.ctx.transport.request<models.SeedConnectorTypesResponse>({
+			method: "POST",
+			path: `/v1/control/dcim/catalog/connectors/seed`,
+		});
+	}
+
+	/** control.dcim.catalog.connectors.delete */
+	async dcimCatalogConnectorsDelete(
+		connectorTypeId: string,
+	): Promise<models.DeleteResultDTO> {
+		return this.ctx.transport.request<models.DeleteResultDTO>({
+			method: "DELETE",
+			path: `/v1/control/dcim/catalog/connectors/${connectorTypeId}`,
+		});
+	}
+
+	/** control.dcim.catalog.connectors.mate */
+	async dcimCatalogConnectorsMate(
+		connectorTypeId: string,
+		body: models.SetConnectorMatingRequest,
+	): Promise<models.ConnectorTypeDTO> {
+		return this.ctx.transport.request<models.ConnectorTypeDTO>({
+			method: "POST",
+			path: `/v1/control/dcim/catalog/connectors/${connectorTypeId}/mates`,
+			body,
+		});
+	}
+
+	/** control.dcim.catalog.connectors.unmate */
+	async dcimCatalogConnectorsUnmate(
+		connectorTypeId: string,
+	): Promise<models.DeleteResultDTO> {
+		return this.ctx.transport.request<models.DeleteResultDTO>({
+			method: "DELETE",
+			path: `/v1/control/dcim/catalog/connectors/${connectorTypeId}/mates/${this.id}`,
+		});
+	}
+}

package/resources/ControlDcimPowerConnection.ts

@@ -0,0 +1,84 @@
+// 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 ControlDcimPowerConnection extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.dcim.powerConnections.check */
+	async controlDcimPowerConnectionsCheck(params?: {
+		sourceInterfaceId?: string;
+		targetInterfaceId?: string;
+	}): Promise<models.PowerCompatibilityResponse> {
+		return fetchCachedOrThrow<models.PowerCompatibilityResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/dcim/power-interfaces/check`,
+				query: {
+					source_interface_id: params?.sourceInterfaceId,
+					target_interface_id: params?.targetInterfaceId,
+				},
+			},
+		);
+	}
+
+	/** control.dcim.powerConnections.list */
+	async controlDcimPowerConnectionsList(params?: {
+		interfaceId?: string;
+		ownerKind?: string;
+		ownerId?: string;
+		cableAssetId?: string;
+		includeHistory?: boolean;
+		limit?: number;
+	}): Promise<models.PowerConnectionListResponse> {
+		return fetchCachedOrThrow<models.PowerConnectionListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/dcim/power-interfaces/connections`,
+				query: {
+					interface_id: params?.interfaceId,
+					owner_kind: params?.ownerKind,
+					owner_id: params?.ownerId,
+					cable_asset_id: params?.cableAssetId,
+					include_history: params?.includeHistory,
+					limit: params?.limit,
+				},
+			},
+		);
+	}
+
+	/** control.dcim.powerConnections.connect */
+	async dcimPowerConnectionsConnect(
+		body: models.ConnectPowerInterfaceRequest,
+	): Promise<models.ConnectPowerResponse> {
+		return this.ctx.transport.request<models.ConnectPowerResponse>({
+			method: "POST",
+			path: `/v1/control/dcim/power-interfaces/connections`,
+			body,
+		});
+	}
+
+	/** control.dcim.powerConnections.disconnect */
+	async dcimPowerConnectionsDisconnect(
+		body: models.DisconnectPowerRequest,
+	): Promise<models.PowerConnectionDTO> {
+		return this.ctx.transport.request<models.PowerConnectionDTO>({
+			method: "POST",
+			path: `/v1/control/dcim/power-interfaces/connections/${this.id}/disconnect`,
+			body,
+		});
+	}
+}

package/resources/ControlDcimPowerGroup.ts

@@ -0,0 +1,51 @@
+// 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 ControlDcimPowerGroup extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.dcim.powerGroups.list */
+	async controlDcimPowerGroupsList(params?: {
+		ownerKind?: string;
+		ownerId?: string;
+	}): Promise<models.PowerGroupListResponse> {
+		return fetchCachedOrThrow<models.PowerGroupListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/dcim/power-interfaces/groups`,
+				query: { owner_kind: params?.ownerKind, owner_id: params?.ownerId },
+			},
+		);
+	}
+
+	/** control.dcim.powerGroups.upsert */
+	async dcimPowerGroupsUpsert(
+		body: models.UpsertPowerGroupRequest,
+	): Promise<models.PowerGroupDTO> {
+		return this.ctx.transport.request<models.PowerGroupDTO>({
+			method: "POST",
+			path: `/v1/control/dcim/power-interfaces/groups`,
+			body,
+		});
+	}
+
+	/** control.dcim.powerGroups.delete */
+	async dcimPowerGroupsDelete(): Promise<models.DeleteResultDTO> {
+		return this.ctx.transport.request<models.DeleteResultDTO>({
+			method: "DELETE",
+			path: `/v1/control/dcim/power-interfaces/groups/${this.id}`,
+		});
+	}
+}

package/resources/ControlDcimPowerInterface.ts

@@ -0,0 +1,67 @@
+// 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 ControlDcimPowerInterface extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.dcim.powerInterfaces.list */
+	async controlDcimPowerInterfacesList(params?: {
+		ownerKind?: string;
+		ownerId?: string;
+		direction?: string;
+	}): Promise<models.PowerInterfaceListResponse> {
+		return fetchCachedOrThrow<models.PowerInterfaceListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/dcim/power-interfaces`,
+				query: {
+					owner_kind: params?.ownerKind,
+					owner_id: params?.ownerId,
+					direction: params?.direction,
+				},
+			},
+		);
+	}
+
+	/** control.dcim.powerInterfaces.upsert */
+	async dcimPowerInterfacesUpsert(
+		body: models.UpsertPowerInterfaceRequest,
+	): Promise<models.PowerInterfaceDTO> {
+		return this.ctx.transport.request<models.PowerInterfaceDTO>({
+			method: "POST",
+			path: `/v1/control/dcim/power-interfaces`,
+			body,
+		});
+	}
+
+	/** control.dcim.powerInterfaces.set */
+	async dcimPowerInterfacesSet(
+		body: models.SetPowerInterfacesRequest,
+	): Promise<models.PowerInterfaceListResponse> {
+		return this.ctx.transport.request<models.PowerInterfaceListResponse>({
+			method: "POST",
+			path: `/v1/control/dcim/power-interfaces/set`,
+			body,
+		});
+	}
+
+	/** control.dcim.powerInterfaces.delete */
+	async dcimPowerInterfacesDelete(): Promise<models.DeleteResultDTO> {
+		return this.ctx.transport.request<models.DeleteResultDTO>({
+			method: "DELETE",
+			path: `/v1/control/dcim/power-interfaces/${this.id}`,
+		});
+	}
+}