@leavepulse/control-sdk 0.3.31 → 0.3.32

package/client.ts

@@ -13,9 +13,12 @@ import { ControlCfAccount } from "./resources/ControlCfAccount";
 import { ControlDcimAcceptance } from "./resources/ControlDcimAcceptance";
 import { ControlDcimCable } from "./resources/ControlDcimCable";
 import { ControlDcimComponent } from "./resources/ControlDcimComponent";
+import { ControlDcimComponentType } from "./resources/ControlDcimComponentType";
 import { ControlDcimDevice } from "./resources/ControlDcimDevice";
+import { ControlDcimDeviceType } from "./resources/ControlDcimDeviceType";
 import { ControlDcimFeed } from "./resources/ControlDcimFeed";
 import { ControlDcimLocation } from "./resources/ControlDcimLocation";
+import { ControlDcimManufacturer } from "./resources/ControlDcimManufacturer";
 import { ControlDcimOutlet } from "./resources/ControlDcimOutlet";
 import { ControlDcimPdu } from "./resources/ControlDcimPdu";
 import { ControlDcimPort } from "./resources/ControlDcimPort";
@@ -45,6 +48,7 @@ export class LeavePulse {
 	private readonly ctx: ClientContext;
 	private _controlagentrelease?: ControlAgentRelease;
 	private _controlalert?: ControlAlert;
+	private _controldcimmanufacturer?: ControlDcimManufacturer;
 	private _controlproject?: ControlProject;
 	readonly auth: AuthNs;
 	readonly control: ControlNs;
@@ -127,6 +131,14 @@ export class LeavePulse {
 		) as ControlDcimComponent;
 	}
 
+	controldcimcomponenttype(id: string): ControlDcimComponentType {
+		return this.ctx.cache.ensure(
+			"ControlDcimComponentType",
+			id,
+			() => new ControlDcimComponentType({ id } as never, this.ctx),
+		) as ControlDcimComponentType;
+	}
+
 	controldcimdevice(id: string): ControlDcimDevice {
 		return this.ctx.cache.ensure(
 			"ControlDcimDevice",
@@ -135,6 +147,14 @@ export class LeavePulse {
 		) as ControlDcimDevice;
 	}
 
+	controldcimdevicetype(id: string): ControlDcimDeviceType {
+		return this.ctx.cache.ensure(
+			"ControlDcimDeviceType",
+			id,
+			() => new ControlDcimDeviceType({ id } as never, this.ctx),
+		) as ControlDcimDeviceType;
+	}
+
 	controldcimfeed(id: string): ControlDcimFeed {
 		return this.ctx.cache.ensure(
 			"ControlDcimFeed",
@@ -151,6 +171,14 @@ export class LeavePulse {
 		) as ControlDcimLocation;
 	}
 
+	get controldcimmanufacturer(): ControlDcimManufacturer {
+		this._controldcimmanufacturer ??= new ControlDcimManufacturer(
+			{} as never,
+			this.ctx,
+		);
+		return this._controldcimmanufacturer;
+	}
+
 	controldcimoutlet(id: string): ControlDcimOutlet {
 		return this.ctx.cache.ensure(
 			"ControlDcimOutlet",
@@ -277,9 +305,15 @@ export class LeavePulse {
 			ControlDcimCable: (d) => new ControlDcimCable(d as never, this.ctx),
 			ControlDcimComponent: (d) =>
 				new ControlDcimComponent(d as never, this.ctx),
+			ControlDcimComponentType: (d) =>
+				new ControlDcimComponentType(d as never, this.ctx),
 			ControlDcimDevice: (d) => new ControlDcimDevice(d as never, this.ctx),
+			ControlDcimDeviceType: (d) =>
+				new ControlDcimDeviceType(d as never, this.ctx),
 			ControlDcimFeed: (d) => new ControlDcimFeed(d as never, this.ctx),
 			ControlDcimLocation: (d) => new ControlDcimLocation(d as never, this.ctx),
+			ControlDcimManufacturer: (d) =>
+				new ControlDcimManufacturer(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),

package/index.ts

@@ -9,9 +9,12 @@ export { ControlCfAccount } from "./resources/ControlCfAccount";
 export { ControlDcimAcceptance } from "./resources/ControlDcimAcceptance";
 export { ControlDcimCable } from "./resources/ControlDcimCable";
 export { ControlDcimComponent } from "./resources/ControlDcimComponent";
+export { ControlDcimComponentType } from "./resources/ControlDcimComponentType";
 export { ControlDcimDevice } from "./resources/ControlDcimDevice";
+export { ControlDcimDeviceType } from "./resources/ControlDcimDeviceType";
 export { ControlDcimFeed } from "./resources/ControlDcimFeed";
 export { ControlDcimLocation } from "./resources/ControlDcimLocation";
+export { ControlDcimManufacturer } from "./resources/ControlDcimManufacturer";
 export { ControlDcimOutlet } from "./resources/ControlDcimOutlet";
 export { ControlDcimPdu } from "./resources/ControlDcimPdu";
 export { ControlDcimPort } from "./resources/ControlDcimPort";

package/models.ts

@@ -24,6 +24,9 @@ export type CfAccountListResponse =
 export type ComponentDTO = components["schemas"]["ComponentDTO"];
 export type ComponentListResponse =
 	components["schemas"]["ComponentListResponse"];
+export type ComponentTypeDTO = components["schemas"]["ComponentTypeDTO"];
+export type ComponentTypeListResponse =
+	components["schemas"]["ComponentTypeListResponse"];
 export type ComposePreviewDTO = components["schemas"]["ComposePreviewDTO"];
 export type ConfigFileDTO = components["schemas"]["ConfigFileDTO"];
 export type ConnectPowerRequest = components["schemas"]["ConnectPowerRequest"];
@@ -65,6 +68,11 @@ export type DeploymentListResponse =
 export type DetectedExporterDTO = components["schemas"]["DetectedExporterDTO"];
 export type DeviceDTO = components["schemas"]["DeviceDTO"];
 export type DeviceListResponse = components["schemas"]["DeviceListResponse"];
+export type DeviceTypeDTO = components["schemas"]["DeviceTypeDTO"];
+export type DeviceTypeListResponse =
+	components["schemas"]["DeviceTypeListResponse"];
+export type DeviceTypePortDTO = components["schemas"]["DeviceTypePortDTO"];
+export type DeviceTypePortInput = components["schemas"]["DeviceTypePortInput"];
 export type DiskCategory = components["schemas"]["DiskCategory"];
 export type DiskUsageDTO = components["schemas"]["DiskUsageDTO"];
 export type DisputeAcceptanceRequest =
@@ -94,6 +102,11 @@ export type FirewallRulesResponse =
 export type HostCapabilitiesDTO = components["schemas"]["HostCapabilitiesDTO"];
 export type HostDTO = components["schemas"]["HostDTO"];
 export type HostListResponse = components["schemas"]["HostListResponse"];
+export type ImportDeviceTypesRequest =
+	components["schemas"]["ImportDeviceTypesRequest"];
+export type ImportDeviceTypesResponse =
+	components["schemas"]["ImportDeviceTypesResponse"];
+export type ImportDocumentInput = components["schemas"]["ImportDocumentInput"];
 export type InspectResponse = components["schemas"]["InspectResponse"];
 export type InstallExporterRequest =
 	components["schemas"]["InstallExporterRequest"];
@@ -102,6 +115,9 @@ export type InstallExporterResponse =
 export type LocationDTO = components["schemas"]["LocationDTO"];
 export type LocationListResponse =
 	components["schemas"]["LocationListResponse"];
+export type ManufacturerDTO = components["schemas"]["ManufacturerDTO"];
+export type ManufacturerListResponse =
+	components["schemas"]["ManufacturerListResponse"];
 export type NodeDTO = components["schemas"]["NodeDTO"];
 export type OutletDTO = components["schemas"]["OutletDTO"];
 export type OutletListResponse = components["schemas"]["OutletListResponse"];
@@ -146,6 +162,8 @@ export type SetAcceptanceItemsRequest =
 	components["schemas"]["SetAcceptanceItemsRequest"];
 export type SetCanvasViewRequest =
 	components["schemas"]["SetCanvasViewRequest"];
+export type SetDeviceTypePortsRequest =
+	components["schemas"]["SetDeviceTypePortsRequest"];
 export type SetPositionRequest = components["schemas"]["SetPositionRequest"];
 export type SetRoleRequest = components["schemas"]["SetRoleRequest"];
 export type SignAcceptanceRequest =
@@ -173,11 +191,17 @@ 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 UpsertComponentTypeRequest =
+	components["schemas"]["UpsertComponentTypeRequest"];
+export type UpsertDeviceTypeRequest =
+	components["schemas"]["UpsertDeviceTypeRequest"];
 export type UpsertDnsRecordRequest =
 	components["schemas"]["UpsertDnsRecordRequest"];
 export type UpsertEdgeRequest = components["schemas"]["UpsertEdgeRequest"];
 export type UpsertEnvGroupRequest =
 	components["schemas"]["UpsertEnvGroupRequest"];
+export type UpsertManufacturerRequest =
+	components["schemas"]["UpsertManufacturerRequest"];
 export type UpsertNodeRequest = components["schemas"]["UpsertNodeRequest"];
 export type UpsertProjectRequest =
 	components["schemas"]["UpsertProjectRequest"];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@leavepulse/control-sdk",
-	"version": "0.3.31",
+	"version": "0.3.32",
 	"description": "Generated resource SDK (@leavepulse/control-sdk).",
 	"type": "module",
 	"module": "index.ts",
@@ -10,8 +10,7 @@
 		"url": "git+https://github.com/LeavePulse/leavepulse-sdk-control-ts.git"
 	},
 	"publishConfig": {
-		"registry": "https://registry.npmjs.org",
-		"access": "public"
+		"registry": "https://npm.pkg.github.com"
 	},
 	"exports": {
 		".": "./index.ts",

package/resources/ControlDcimComponentType.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 ControlDcimComponentType extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.dcim.catalog.component_types.list */
+	async controlDcimCatalogComponentTypesList(params?: {
+		manufacturer?: string;
+		kind?: string;
+		search?: string;
+	}): Promise<models.ComponentTypeListResponse> {
+		return fetchCachedOrThrow<models.ComponentTypeListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/dcim/catalog/component-types`,
+				query: {
+					manufacturer: params?.manufacturer,
+					kind: params?.kind,
+					search: params?.search,
+				},
+			},
+		);
+	}
+
+	/** control.dcim.catalog.component_types.upsert */
+	async dcimCatalogComponentTypesUpsert(
+		body: models.UpsertComponentTypeRequest,
+	): Promise<models.ComponentTypeDTO> {
+		return this.ctx.transport.request<models.ComponentTypeDTO>({
+			method: "POST",
+			path: `/v1/control/dcim/catalog/component-types`,
+			body,
+		});
+	}
+
+	/** control.dcim.catalog.component_types.delete */
+	async dcimCatalogComponentTypesDelete(): Promise<models.DeleteResultDTO> {
+		return this.ctx.transport.request<models.DeleteResultDTO>({
+			method: "DELETE",
+			path: `/v1/control/dcim/catalog/component-types/${this.id}`,
+		});
+	}
+}

package/resources/ControlDcimDeviceType.ts

@@ -0,0 +1,92 @@
+// 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 ControlDcimDeviceType extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.dcim.catalog.device_types.list */
+	async controlDcimCatalogDeviceTypesList(params?: {
+		manufacturer?: string;
+		kind?: string;
+		search?: string;
+		completeOnly?: boolean;
+	}): Promise<models.DeviceTypeListResponse> {
+		return fetchCachedOrThrow<models.DeviceTypeListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/dcim/catalog/device-types`,
+				query: {
+					manufacturer: params?.manufacturer,
+					kind: params?.kind,
+					search: params?.search,
+					complete_only: params?.completeOnly,
+				},
+			},
+		);
+	}
+
+	/** control.dcim.catalog.device_types.get */
+	async controlDcimCatalogDeviceTypesGet(): Promise<models.DeviceTypeDTO> {
+		return fetchCachedOrThrow<models.DeviceTypeDTO>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{
+				method: "GET",
+				path: `/v1/control/dcim/catalog/device-types/${this.id}`,
+			},
+		);
+	}
+
+	/** control.dcim.catalog.device_types.upsert */
+	async dcimCatalogDeviceTypesUpsert(
+		body: models.UpsertDeviceTypeRequest,
+	): Promise<models.DeviceTypeDTO> {
+		return this.ctx.transport.request<models.DeviceTypeDTO>({
+			method: "POST",
+			path: `/v1/control/dcim/catalog/device-types`,
+			body,
+		});
+	}
+
+	/** control.dcim.catalog.device_types.delete */
+	async dcimCatalogDeviceTypesDelete(): Promise<models.DeleteResultDTO> {
+		return this.ctx.transport.request<models.DeleteResultDTO>({
+			method: "DELETE",
+			path: `/v1/control/dcim/catalog/device-types/${this.id}`,
+		});
+	}
+
+	/** control.dcim.catalog.device_types.set_ports */
+	async dcimCatalogDeviceTypesSetPorts(
+		body: models.SetDeviceTypePortsRequest,
+	): Promise<models.DeviceTypeDTO> {
+		return this.ctx.transport.request<models.DeviceTypeDTO>({
+			method: "POST",
+			path: `/v1/control/dcim/catalog/device-types/${this.id}/ports`,
+			body,
+		});
+	}
+
+	/** control.dcim.catalog.import */
+	async dcimCatalogImport(
+		body: models.ImportDeviceTypesRequest,
+	): Promise<models.ImportDeviceTypesResponse> {
+		return this.ctx.transport.request<models.ImportDeviceTypesResponse>({
+			method: "POST",
+			path: `/v1/control/dcim/catalog/import`,
+			body,
+		});
+	}
+}

package/resources/ControlDcimManufacturer.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 ControlDcimManufacturer extends Resource<Data> {
+	constructor(
+		data: Data,
+		private readonly ctx: ClientContext,
+	) {
+		super(data);
+	}
+
+	/** control.dcim.catalog.manufacturers.list */
+	async controlDcimCatalogManufacturersList(): Promise<models.ManufacturerListResponse> {
+		return fetchCachedOrThrow<models.ManufacturerListResponse>(
+			this.ctx.transport,
+			this.ctx.etagStore,
+			{ method: "GET", path: `/v1/control/dcim/catalog/manufacturers` },
+		);
+	}
+
+	/** control.dcim.catalog.manufacturers.upsert */
+	async dcimCatalogManufacturersUpsert(
+		body: models.UpsertManufacturerRequest,
+	): Promise<models.ManufacturerDTO> {
+		return this.ctx.transport.request<models.ManufacturerDTO>({
+			method: "POST",
+			path: `/v1/control/dcim/catalog/manufacturers`,
+			body,
+		});
+	}
+}

package/types.ts

@@ -456,6 +456,129 @@ export interface paths {
 		patch: operations["control.dcim.cables.update"];
 		trace?: never;
 	};
+	"/v1/control/dcim/catalog/component-types": {
+		parameters: {
+			query?: never;
+			header?: never;
+			path?: never;
+			cookie?: never;
+		};
+		/** ListComponentTypes */
+		get: operations["control.dcim.catalog.component_types.list"];
+		put?: never;
+		/** UpsertComponentType */
+		post: operations["control.dcim.catalog.component_types.upsert"];
+		delete?: never;
+		options?: never;
+		head?: never;
+		patch?: never;
+		trace?: never;
+	};
+	"/v1/control/dcim/catalog/component-types/{component_type_id}": {
+		parameters: {
+			query?: never;
+			header?: never;
+			path?: never;
+			cookie?: never;
+		};
+		get?: never;
+		put?: never;
+		post?: never;
+		/** DeleteComponentType */
+		delete: operations["control.dcim.catalog.component_types.delete"];
+		options?: never;
+		head?: never;
+		patch?: never;
+		trace?: never;
+	};
+	"/v1/control/dcim/catalog/device-types": {
+		parameters: {
+			query?: never;
+			header?: never;
+			path?: never;
+			cookie?: never;
+		};
+		/** ListDeviceTypes */
+		get: operations["control.dcim.catalog.device_types.list"];
+		put?: never;
+		/** UpsertDeviceType */
+		post: operations["control.dcim.catalog.device_types.upsert"];
+		delete?: never;
+		options?: never;
+		head?: never;
+		patch?: never;
+		trace?: never;
+	};
+	"/v1/control/dcim/catalog/device-types/{device_type_id}": {
+		parameters: {
+			query?: never;
+			header?: never;
+			path?: never;
+			cookie?: never;
+		};
+		/** GetDeviceType */
+		get: operations["control.dcim.catalog.device_types.get"];
+		put?: never;
+		post?: never;
+		/** DeleteDeviceType */
+		delete: operations["control.dcim.catalog.device_types.delete"];
+		options?: never;
+		head?: never;
+		patch?: never;
+		trace?: never;
+	};
+	"/v1/control/dcim/catalog/device-types/{device_type_id}/ports": {
+		parameters: {
+			query?: never;
+			header?: never;
+			path?: never;
+			cookie?: never;
+		};
+		get?: never;
+		put?: never;
+		/** SetDeviceTypePorts */
+		post: operations["control.dcim.catalog.device_types.set_ports"];
+		delete?: never;
+		options?: never;
+		head?: never;
+		patch?: never;
+		trace?: never;
+	};
+	"/v1/control/dcim/catalog/import": {
+		parameters: {
+			query?: never;
+			header?: never;
+			path?: never;
+			cookie?: never;
+		};
+		get?: never;
+		put?: never;
+		/** ImportDeviceTypes */
+		post: operations["control.dcim.catalog.import"];
+		delete?: never;
+		options?: never;
+		head?: never;
+		patch?: never;
+		trace?: never;
+	};
+	"/v1/control/dcim/catalog/manufacturers": {
+		parameters: {
+			query?: never;
+			header?: never;
+			path?: never;
+			cookie?: never;
+		};
+		/** ListManufacturers */
+		get: operations["control.dcim.catalog.manufacturers.list"];
+		put?: never;
+		/** UpsertManufacturer */
+		post: operations["control.dcim.catalog.manufacturers.upsert"];
+		delete?: never;
+		options?: never;
+		head?: never;
+		patch?: never;
+		trace?: never;
+	};
 	"/v1/control/dcim/components": {
 		parameters: {
 			query?: never;
@@ -1521,6 +1644,26 @@ export interface components {
 		ComponentListResponse: {
 			items: components["schemas"]["ComponentDTO"][];
 		};
+		/** ComponentTypeDTO */
+		ComponentTypeDTO: {
+			capacity_bytes: string;
+			id: string;
+			is_complete: boolean;
+			kind: string;
+			manufacturer_id: string;
+			manufacturer_name: string;
+			model: string;
+			notes: string;
+			part_number: string;
+			power_w: number;
+			source: string;
+			source_ref: string;
+			spec: string;
+		};
+		/** ComponentTypeListResponse */
+		ComponentTypeListResponse: {
+			items: components["schemas"]["ComponentTypeDTO"][];
+		};
 		/** ComposePreviewDTO */
 		ComposePreviewDTO: {
 			compose_payload: string;
@@ -1611,6 +1754,8 @@ export interface components {
 			/** @default  */
 			asset_tag?: string;
 			/** @default  */
+			component_type_id?: string;
+			/** @default  */
 			confidence?: string;
 			/** @default  */
 			device_id?: string;
@@ -1631,6 +1776,8 @@ export interface components {
 			/** @default  */
 			confidence?: string;
 			/** @default  */
+			device_type_id?: string;
+			/** @default  */
 			host_ref?: string;
 			kind: string;
 			/** @default  */
@@ -1813,6 +1960,57 @@ export interface components {
 		DeviceListResponse: {
 			items: components["schemas"]["DeviceDTO"][];
 		};
+		/** DeviceTypeDTO */
+		DeviceTypeDTO: {
+			depth_mm: number;
+			height_mm: number;
+			id: string;
+			is_complete: boolean;
+			is_full_depth: boolean;
+			kind: string;
+			manufacturer_id: string;
+			manufacturer_name: string;
+			max_draw_w: number;
+			model: string;
+			notes: string;
+			part_number: string;
+			ports?: components["schemas"]["DeviceTypePortDTO"][];
+			power_input: string;
+			power_type: string;
+			slug: string;
+			source: string;
+			source_ref: string;
+			u_height: number;
+			weight_g: number;
+			width_mm: number;
+		};
+		/** DeviceTypeListResponse */
+		DeviceTypeListResponse: {
+			items: components["schemas"]["DeviceTypeDTO"][];
+		};
+		/** DeviceTypePortDTO */
+		DeviceTypePortDTO: {
+			id: string;
+			kind: string;
+			label: string;
+			poe_mode: string;
+			position: number;
+			side: string;
+			speed: string;
+		};
+		/** DeviceTypePortInput */
+		DeviceTypePortInput: {
+			kind: string;
+			label: string;
+			/** @default  */
+			poe_mode: string;
+			/** @default 0 */
+			position: number;
+			/** @default back */
+			side: string;
+			/** @default  */
+			speed: string;
+		};
 		/** DiskCategory */
 		DiskCategory: {
 			/** @default 0 */
@@ -1982,6 +2180,22 @@ export interface components {
 		HostListResponse: {
 			items: components["schemas"]["HostDTO"][];
 		};
+		/** ImportDeviceTypesRequest */
+		ImportDeviceTypesRequest: {
+			documents: components["schemas"]["ImportDocumentInput"][];
+		};
+		/** ImportDeviceTypesResponse */
+		ImportDeviceTypesResponse: {
+			failed: string[];
+			imported: components["schemas"]["DeviceTypeDTO"][];
+			skipped_edited: string[];
+		};
+		/** ImportDocumentInput */
+		ImportDocumentInput: {
+			/** @default  */
+			source_ref: string;
+			yaml: string;
+		};
 		/** InspectResponse */
 		InspectResponse: {
 			container: string;
@@ -2014,6 +2228,16 @@ export interface components {
 		LocationListResponse: {
 			items: components["schemas"]["LocationDTO"][];
 		};
+		/** ManufacturerDTO */
+		ManufacturerDTO: {
+			id: string;
+			name: string;
+			slug: string;
+		};
+		/** ManufacturerListResponse */
+		ManufacturerListResponse: {
+			items: components["schemas"]["ManufacturerDTO"][];
+		};
 		/** NodeDTO */
 		NodeDTO: {
 			/** @default 0 */
@@ -2363,6 +2587,10 @@ export interface components {
 			pan_y: number;
 			zoom: number;
 		};
+		/** SetDeviceTypePortsRequest */
+		SetDeviceTypePortsRequest: {
+			ports: components["schemas"]["DeviceTypePortInput"][];
+		};
 		/** SetPositionRequest */
 		SetPositionRequest: {
 			pos_x: number;
@@ -2512,6 +2740,60 @@ export interface components {
 			pos_row?: string | null;
 			u_height?: number | null;
 		};
+		/** UpsertComponentTypeRequest */
+		UpsertComponentTypeRequest: {
+			/** @default  */
+			capacity_bytes?: string;
+			/** @default  */
+			id?: string;
+			/** @default false */
+			is_complete?: boolean;
+			kind: string;
+			/** @default  */
+			manufacturer_id?: string;
+			model: string;
+			/** @default  */
+			notes?: string;
+			/** @default  */
+			part_number?: string;
+			/** @default 0 */
+			power_w?: number;
+			/** @default  */
+			spec?: string;
+		};
+		/** UpsertDeviceTypeRequest */
+		UpsertDeviceTypeRequest: {
+			/** @default 0 */
+			depth_mm?: number;
+			/** @default 0 */
+			height_mm?: number;
+			/** @default  */
+			id?: string;
+			/** @default false */
+			is_complete?: boolean;
+			/** @default false */
+			is_full_depth?: boolean;
+			kind: string;
+			/** @default  */
+			manufacturer_id?: string;
+			/** @default 0 */
+			max_draw_w?: number;
+			model: string;
+			/** @default  */
+			notes?: string;
+			/** @default  */
+			part_number?: string;
+			/** @default  */
+			power_input?: string;
+			/** @default  */
+			power_type?: string;
+			/** @default 0 */
+			u_height?: number;
+			/** @default 0 */
+			weight_g?: number;
+			/** @default 0 */
+			width_mm?: number;
+		};
 		/** UpsertDnsRecordRequest */
 		UpsertDnsRecordRequest: {
 			content: string;
@@ -2546,6 +2828,12 @@ export interface components {
 			/** @default  */
 			name?: string;
 		};
+		/** UpsertManufacturerRequest */
+		UpsertManufacturerRequest: {
+			/** @default  */
+			id?: string;
+			name: string;
+		};
 		/** UpsertNodeRequest */
 		UpsertNodeRequest: {
 			/** @default  */
@@ -4193,6 +4481,443 @@ export interface operations {
 			};
 		};
 	};
+	"control.dcim.catalog.component_types.list": {
+		parameters: {
+			query?: {
+				manufacturer?: string | null;
+				kind?: string | null;
+				search?: string | null;
+			};
+			header?: never;
+			path?: never;
+			cookie?: never;
+		};
+		requestBody?: never;
+		responses: {
+			/** @description Request fulfilled, document follows */
+			200: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": components["schemas"]["ComponentTypeListResponse"];
+				};
+			};
+			/** @description Bad request syntax or unsupported method */
+			400: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": {
+						detail: string;
+						extra?:
+							| null
+							| {
+									[key: string]: unknown;
+							  }
+							| unknown[];
+						status_code: number;
+					};
+				};
+			};
+		};
+	};
+	"control.dcim.catalog.component_types.upsert": {
+		parameters: {
+			query?: never;
+			header?: never;
+			path?: never;
+			cookie?: never;
+		};
+		requestBody: {
+			content: {
+				"application/json": components["schemas"]["UpsertComponentTypeRequest"];
+			};
+		};
+		responses: {
+			/** @description Document created, URL follows */
+			201: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": components["schemas"]["ComponentTypeDTO"];
+				};
+			};
+			/** @description Bad request syntax or unsupported method */
+			400: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": {
+						detail: string;
+						extra?:
+							| null
+							| {
+									[key: string]: unknown;
+							  }
+							| unknown[];
+						status_code: number;
+					};
+				};
+			};
+		};
+	};
+	"control.dcim.catalog.component_types.delete": {
+		parameters: {
+			query?: never;
+			header?: never;
+			path: {
+				component_type_id: string;
+			};
+			cookie?: never;
+		};
+		requestBody?: never;
+		responses: {
+			/** @description Request fulfilled, document follows */
+			200: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": components["schemas"]["DeleteResultDTO"];
+				};
+			};
+			/** @description Bad request syntax or unsupported method */
+			400: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": {
+						detail: string;
+						extra?:
+							| null
+							| {
+									[key: string]: unknown;
+							  }
+							| unknown[];
+						status_code: number;
+					};
+				};
+			};
+		};
+	};
+	"control.dcim.catalog.device_types.list": {
+		parameters: {
+			query?: {
+				manufacturer?: string | null;
+				kind?: string | null;
+				search?: string | null;
+				complete_only?: boolean;
+			};
+			header?: never;
+			path?: never;
+			cookie?: never;
+		};
+		requestBody?: never;
+		responses: {
+			/** @description Request fulfilled, document follows */
+			200: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": components["schemas"]["DeviceTypeListResponse"];
+				};
+			};
+			/** @description Bad request syntax or unsupported method */
+			400: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": {
+						detail: string;
+						extra?:
+							| null
+							| {
+									[key: string]: unknown;
+							  }
+							| unknown[];
+						status_code: number;
+					};
+				};
+			};
+		};
+	};
+	"control.dcim.catalog.device_types.upsert": {
+		parameters: {
+			query?: never;
+			header?: never;
+			path?: never;
+			cookie?: never;
+		};
+		requestBody: {
+			content: {
+				"application/json": components["schemas"]["UpsertDeviceTypeRequest"];
+			};
+		};
+		responses: {
+			/** @description Document created, URL follows */
+			201: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": components["schemas"]["DeviceTypeDTO"];
+				};
+			};
+			/** @description Bad request syntax or unsupported method */
+			400: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": {
+						detail: string;
+						extra?:
+							| null
+							| {
+									[key: string]: unknown;
+							  }
+							| unknown[];
+						status_code: number;
+					};
+				};
+			};
+		};
+	};
+	"control.dcim.catalog.device_types.get": {
+		parameters: {
+			query?: never;
+			header?: never;
+			path: {
+				device_type_id: string;
+			};
+			cookie?: never;
+		};
+		requestBody?: never;
+		responses: {
+			/** @description Request fulfilled, document follows */
+			200: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": components["schemas"]["DeviceTypeDTO"];
+				};
+			};
+			/** @description Bad request syntax or unsupported method */
+			400: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": {
+						detail: string;
+						extra?:
+							| null
+							| {
+									[key: string]: unknown;
+							  }
+							| unknown[];
+						status_code: number;
+					};
+				};
+			};
+		};
+	};
+	"control.dcim.catalog.device_types.delete": {
+		parameters: {
+			query?: never;
+			header?: never;
+			path: {
+				device_type_id: string;
+			};
+			cookie?: never;
+		};
+		requestBody?: never;
+		responses: {
+			/** @description Request fulfilled, document follows */
+			200: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": components["schemas"]["DeleteResultDTO"];
+				};
+			};
+			/** @description Bad request syntax or unsupported method */
+			400: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": {
+						detail: string;
+						extra?:
+							| null
+							| {
+									[key: string]: unknown;
+							  }
+							| unknown[];
+						status_code: number;
+					};
+				};
+			};
+		};
+	};
+	"control.dcim.catalog.device_types.set_ports": {
+		parameters: {
+			query?: never;
+			header?: never;
+			path: {
+				device_type_id: string;
+			};
+			cookie?: never;
+		};
+		requestBody: {
+			content: {
+				"application/json": components["schemas"]["SetDeviceTypePortsRequest"];
+			};
+		};
+		responses: {
+			/** @description Document created, URL follows */
+			201: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": components["schemas"]["DeviceTypeDTO"];
+				};
+			};
+			/** @description Bad request syntax or unsupported method */
+			400: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": {
+						detail: string;
+						extra?:
+							| null
+							| {
+									[key: string]: unknown;
+							  }
+							| unknown[];
+						status_code: number;
+					};
+				};
+			};
+		};
+	};
+	"control.dcim.catalog.import": {
+		parameters: {
+			query?: never;
+			header?: never;
+			path?: never;
+			cookie?: never;
+		};
+		requestBody: {
+			content: {
+				"application/json": components["schemas"]["ImportDeviceTypesRequest"];
+			};
+		};
+		responses: {
+			/** @description Document created, URL follows */
+			201: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": components["schemas"]["ImportDeviceTypesResponse"];
+				};
+			};
+			/** @description Bad request syntax or unsupported method */
+			400: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": {
+						detail: string;
+						extra?:
+							| null
+							| {
+									[key: string]: unknown;
+							  }
+							| unknown[];
+						status_code: number;
+					};
+				};
+			};
+		};
+	};
+	"control.dcim.catalog.manufacturers.list": {
+		parameters: {
+			query?: never;
+			header?: never;
+			path?: never;
+			cookie?: never;
+		};
+		requestBody?: never;
+		responses: {
+			/** @description Request fulfilled, document follows */
+			200: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": components["schemas"]["ManufacturerListResponse"];
+				};
+			};
+		};
+	};
+	"control.dcim.catalog.manufacturers.upsert": {
+		parameters: {
+			query?: never;
+			header?: never;
+			path?: never;
+			cookie?: never;
+		};
+		requestBody: {
+			content: {
+				"application/json": components["schemas"]["UpsertManufacturerRequest"];
+			};
+		};
+		responses: {
+			/** @description Document created, URL follows */
+			201: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": components["schemas"]["ManufacturerDTO"];
+				};
+			};
+			/** @description Bad request syntax or unsupported method */
+			400: {
+				headers: {
+					[name: string]: unknown;
+				};
+				content: {
+					"application/json": {
+						detail: string;
+						extra?:
+							| null
+							| {
+									[key: string]: unknown;
+							  }
+							| unknown[];
+						status_code: number;
+					};
+				};
+			};
+		};
+	};
 	"control.dcim.components.list": {
 		parameters: {
 			query?: {