@ozmap/ozmap-sdk
Version:
Use this sdk to access ozmap plataform and connect it to your own systems.
1,155 lines (1,110 loc) • 128 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var src_exports = {};
__export(src_exports, {
ApiFilterSchema: () => ApiFilterSchema,
ApiSortDirection: () => ApiSortDirection,
ApiSortSchema: () => ApiSortListSchema,
BaseBoxDataSchema: () => BaseBoxDataSchema,
BaseBoxKind: () => BaseBoxKind,
BaseBoxSchema: () => BaseBoxSchema,
BaseModelSchema: () => BaseModelSchema,
BasePointDataSchema: () => BasePointDataSchema,
BasePointKind: () => BasePointKind,
BasePointSchema: () => BasePointSchema,
BoxSchema: () => BoxSchema,
BoxTemplateSchema: () => BoxTemplateSchema,
BoxTypeSchema: () => BoxTypeSchema,
BuildingSchema: () => BuildingSchema,
BuildingTypeSchema: () => BuildingTypeSchema,
CableSchema: () => CableSchema,
CableStubSchema: () => CableStubSchema,
CableTypeSchema: () => CableTypeSchema,
ColorSchema: () => ColorSchema,
ConnectorSchema: () => ConnectorSchema,
ConnectorTypeSchema: () => ConnectorTypeSchema,
CordSchema: () => CordSchema,
CreateBoxDTOSchema: () => CreateBoxDTOSchema,
CreateBoxTemplateDTOSchema: () => CreateBoxTemplateDTOSchema,
CreateBoxTypeDTOSchema: () => CreateBoxTypeDTOSchema,
CreateBuildingDTOSchema: () => CreateBuildingDTOSchema,
CreateBuildingTypeDTOSchema: () => CreateBuildingTypeDTOSchema,
CreateCableDTOSchema: () => CreateCableDTOSchema,
CreateCableTypeDTOSchema: () => CreateCableTypeDTOSchema,
CreateColorDTOSchema: () => CreateColorDTOSchema,
CreateConnectorDTOSchema: () => CreateConnectorDTOSchema,
CreateConnectorTypeDTOSchema: () => CreateConnectorTypeDTOSchema,
CreateCordDTOSchema: () => CreateCordDTOSchema,
CreateDIODTOSchema: () => CreateDIODTOSchema,
CreateDIOTypeDTOSchema: () => CreateDIOTypeDTOSchema,
CreateDuctDTOSchema: () => CreateDuctDTOSchema,
CreateDuctTypeDTOSchema: () => CreateDuctTypeDTOSchema,
CreateFTTHClientDTOSchema: () => CreateFTTHClientDTOSchema,
CreateFiberProfileDTOSchema: () => CreateFiberProfileDTOSchema,
CreateFusionDTOSchema: () => CreateFusionDTOSchema,
CreateFusionTypeDTOSchema: () => CreateFusionTypeDTOSchema,
CreateHorizontalCondominiumDTOSchema: () => CreateHorizontalCondominiumDTOSchema,
CreateJunctionBoxDTOSchema: () => CreateJunctionBoxDTOSchema,
CreateJunctionBoxTypeDTOSchema: () => CreateJunctionBoxTypeDTOSchema,
CreateOLTDTOSchema: () => CreateOLTDTOSchema,
CreateOLTTypeDTOSchema: () => CreateOLTTypeDTOSchema,
CreatePONDTOSchema: () => CreatePONDTOSchema,
CreatePendencyDTOSchema: () => CreatePendencyDTOSchema,
CreatePendencyTypeDTOSchema: () => CreatePendencyTypeDTOSchema,
CreatePointDTOSchema: () => CreatePointDTOSchema,
CreatePoleDTOSchema: () => CreatePoleDTOSchema,
CreatePoleTypeDTOSchema: () => CreatePoleTypeDTOSchema,
CreatePopDTOSchema: () => CreatePopDTOSchema,
CreatePopTypeDTOSchema: () => CreatePopTypeDTOSchema,
CreatePostDTOSchema: () => CreatePostDTOSchema,
CreateProjectDTOSchema: () => CreateProjectDTOSchema,
CreateProjectGroupDTOSchema: () => CreateProjectGroupDTOSchema,
CreatePropertyDTOSchema: () => CreatePropertyDTOSchema,
CreateProspectDTOSchema: () => CreateProspectDTOSchema,
CreateRegionDTOSchema: () => CreateRegionDTOSchema,
CreateRegionTypeDTOSchema: () => CreateRegionTypeDTOSchema,
CreateRoleDTOSchema: () => CreateRoleDTOSchema,
CreateShelfDTOSchema: () => CreateShelfDTOSchema,
CreateShelfTypeDTOSchema: () => CreateShelfTypeDTOSchema,
CreateSlotDTOSchema: () => CreateSlotDTOSchema,
CreateSplitterDTOSchema: () => CreateSplitterDTOSchema,
CreateSplitterTypeDTOSchema: () => CreateSplitterTypeDTOSchema,
CreateSwitchDTOSchema: () => CreateSwitchDTOSchema,
CreateSwitchTypeDTOSchema: () => CreateSwitchTypeDTOSchema,
CreateSystemConfigDTOSchema: () => CreateSystemConfigDTOSchema,
CreateTagDTOSchema: () => CreateTagDTOSchema,
CreateUserDTOSchema: () => CreateUserDTOSchema,
DEFAULT_BOX_TEMPLATE_ID: () => DEFAULT_BOX_TEMPLATE_ID,
DIOSchema: () => DIOSchema,
DIOTypeSchema: () => DIOTypeSchema,
DuctSchema: () => DuctSchema,
DuctTypeSchema: () => DuctTypeSchema,
FTTHClientSchema: () => FTTHClientSchema,
FTTHClientStatus: () => FTTHClientStatus,
FiberProfileSchema: () => FiberProfileSchema,
FiberSchema: () => FiberSchema,
FileSchema: () => FileSchema,
FilterOperator: () => FilterOperator,
FusionSchema: () => FusionSchema,
FusionTypeSchema: () => FusionTypeSchema,
HorizontalCondominiumSchema: () => HorizontalCondominiumSchema,
JunctionBoxSchema: () => JunctionBoxSchema,
JunctionBoxTypeSchema: () => JunctionBoxTypeSchema,
NetworkConnectableDataSchema: () => NetworkConnectableDataSchema,
NetworkConnectableKind: () => NetworkConnectableKind,
NetworkConnectableSchema: () => NetworkConnectableSchema,
NetworkConnectorDataSchema: () => NetworkConnectorDataSchema,
NetworkConnectorKind: () => NetworkConnectorKind,
NetworkConnectorSchema: () => NetworkConnectorSchema,
OLTSchema: () => OLTSchema,
OLTTypeSchema: () => OLTTypeSchema,
PONSchema: () => PONSchema,
PassingSchema: () => PassingSchema,
PendencySchema: () => PendencySchema,
PendencyTypeSchema: () => PendencyTypeSchema,
PointSchema: () => PointSchema,
PoleLicensingStatus: () => PoleLicensingStatus,
PoleSchema: () => PoleSchema,
PoleTypeSchema: () => PoleTypeSchema,
PopSchema: () => PopSchema,
PopTypeSchema: () => PopTypeSchema,
PostSchema: () => PostSchema,
ProjectGroupSchema: () => ProjectGroupSchema,
ProjectSchema: () => ProjectSchema,
PropertySchema: () => PropertySchema,
ProspectSchema: () => ProspectSchema,
RegionSchema: () => RegionSchema,
RegionTypeSchema: () => RegionTypeSchema,
RoleSchema: () => RoleSchema,
ShelfSchema: () => ShelfSchema,
ShelfTypeSchema: () => ShelfTypeSchema,
SlotSchema: () => SlotSchema,
SplitterConnectionType: () => SplitterConnectionType,
SplitterSchema: () => SplitterSchema,
SplitterTypeSchema: () => SplitterTypeSchema,
SubDuctStructureSchema: () => SubDuctStructureSchema,
SwitchSchema: () => SwitchSchema,
SwitchTypeSchema: () => SwitchTypeSchema,
SystemConfigSchema: () => SystemConfigSchema,
TagSchema: () => TagSchema,
UpdateBoxDTOSchema: () => UpdateBoxDTOSchema,
UpdateBoxTemplateDTOSchema: () => UpdateBoxTemplateDTOSchema,
UpdateBoxTypeDTOSchema: () => UpdateBoxTypeDTOSchema,
UpdateBuildingDTOSchema: () => UpdateBuildingDTOSchema,
UpdateBuildingTypeDTOSchema: () => UpdateBuildingTypeDTOSchema,
UpdateCableDTOSchema: () => UpdateCableDTOSchema,
UpdateCableTypeDTOSchema: () => UpdateCableTypeDTOSchema,
UpdateColorDTOSchema: () => UpdateColorDTOSchema,
UpdateConnectorDTOSchema: () => UpdateConnectorDTOSchema,
UpdateConnectorTypeDTOSchema: () => UpdateConnectorTypeDTOSchema,
UpdateCordDTOSchema: () => UpdateCordDTOSchema,
UpdateDIODTOSchema: () => UpdateDIODTOSchema,
UpdateDIOTypeDTOSchema: () => UpdateDIOTypeDTOSchema,
UpdateDuctDTOSchema: () => UpdateDuctDTOSchema,
UpdateDuctTypeDTOSchema: () => UpdateDuctTypeDTOSchema,
UpdateFTTHClientDTOSchema: () => UpdateFTTHClientDTOSchema,
UpdateFiberDTOSchema: () => UpdateFiberDTOSchema,
UpdateFiberProfileDTOSchema: () => UpdateFiberProfileDTOSchema,
UpdateFusionDTOSchema: () => UpdateFusionDTOSchema,
UpdateFusionTypeDTOSchema: () => UpdateFusionTypeDTOSchema,
UpdateHorizontalCondominiumDTOSchema: () => UpdateHorizontalCondominiumDTOSchema,
UpdateJunctionBoxDTOSchema: () => UpdateJunctionBoxDTOSchema,
UpdateJunctionBoxTypeDTOSchema: () => UpdateJunctionBoxTypeDTOSchema,
UpdateOLTDTOSchema: () => UpdateOLTDTOSchema,
UpdateOLTTypeDTOSchema: () => UpdateOLTTypeDTOSchema,
UpdatePONDTOSchema: () => UpdatePONDTOSchema,
UpdatePendencyDTOSchema: () => UpdatePendencyDTOSchema,
UpdatePendencyTypeDTOSchema: () => UpdatePendencyTypeDTOSchema,
UpdatePointDTOSchema: () => UpdatePointDTOSchema,
UpdatePoleDTOSchema: () => UpdatePoleDTOSchema,
UpdatePoleTypeDTOSchema: () => UpdatePoleTypeDTOSchema,
UpdatePopDTOSchema: () => UpdatePopDTOSchema,
UpdatePopTypeDTOSchema: () => UpdatePopTypeDTOSchema,
UpdatePostDTOSchema: () => UpdatePostDTOSchema,
UpdateProjectDTOSchema: () => UpdateProjectDTOSchema,
UpdateProjectGroupDTOSchema: () => UpdateProjectGroupDTOSchema,
UpdatePropertyDTOSchema: () => UpdatePropertyDTOSchema,
UpdateProspectDTOSchema: () => UpdateProspectDTOSchema,
UpdateRegionDTOSchema: () => UpdateRegionDTOSchema,
UpdateRegionTypeDTOSchema: () => UpdateRegionTypeDTOSchema,
UpdateRoleDTOSchema: () => UpdateRoleDTOSchema,
UpdateShelfDTOSchema: () => UpdateShelfDTOSchema,
UpdateShelfTypeDTOSchema: () => UpdateShelfTypeDTOSchema,
UpdateSlotDTOSchema: () => UpdateSlotDTOSchema,
UpdateSplitterDTOSchema: () => UpdateSplitterDTOSchema,
UpdateSplitterTypeDTOSchema: () => UpdateSplitterTypeDTOSchema,
UpdateSwitchDTOSchema: () => UpdateSwitchDTOSchema,
UpdateSwitchTypeDTOSchema: () => UpdateSwitchTypeDTOSchema,
UpdateSystemConfigDTOSchema: () => UpdateSystemConfigDTOSchema,
UpdateTagDTOSchema: () => UpdateTagDTOSchema,
UpdateUserDTOSchema: () => UpdateUserDTOSchema,
UserSchema: () => UserSchema,
coordinates: () => coordinates,
default: () => src_default,
externalId: () => externalId,
stringOrObjectId: () => stringOrObjectId
});
module.exports = __toCommonJS(src_exports);
// src/util/Api.ts
var import_logger = __toESM(require("@ozmap/logger"));
var import_axios = __toESM(require("axios"));
var import_http_status_codes = require("http-status-codes");
var import_lodash2 = __toESM(require("lodash"));
// src/interface/model/BaseModel.ts
var import_bson_objectid = __toESM(require("bson-objectid"));
var import_zod = require("zod");
var externalId = import_zod.z.any().optional();
var stringOrObjectId = import_zod.z.string().or(import_zod.z.instanceof(import_bson_objectid.default, { message: "NOT_OBJECT_ID" }));
var coordinates = import_zod.z.tuple([import_zod.z.number(), import_zod.z.number()]).refine((it) => {
return it.length === 2 && it[0] >= -180 && it[0] <= 180 && it[1] >= -90 && it[1] <= 90;
});
var BaseModelSchema = import_zod.z.object({
_id: stringOrObjectId.optional(),
id: stringOrObjectId,
external_id: import_zod.z.string().optional(),
creatorData: import_zod.z.object({
id: stringOrObjectId,
name: import_zod.z.string(),
username: import_zod.z.string()
}).optional(),
createdAt: import_zod.z.date().or(import_zod.z.string()),
updatedAt: import_zod.z.date().or(import_zod.z.string()),
deletedAt: import_zod.z.date().optional()
});
// src/interface/model/BaseBox.ts
var import_zod2 = require("zod");
var BaseBoxKind = /* @__PURE__ */ ((BaseBoxKind2) => {
BaseBoxKind2["BOX"] = "Box";
BaseBoxKind2["BUILDING"] = "Building";
BaseBoxKind2["PROPERTY"] = "Property";
BaseBoxKind2["POP"] = "Pop";
BaseBoxKind2["CABLE_STUB"] = "CableStub";
return BaseBoxKind2;
})(BaseBoxKind || {});
var BaseBoxDataSchema = import_zod2.z.object({
tags: import_zod2.z.array(stringOrObjectId).default([]),
project: stringOrObjectId,
cables: import_zod2.z.array(stringOrObjectId).default([]),
pole: stringOrObjectId.optional(),
// // todo quando tiver 5G, mas cuidar com ACL do OZmap
// towers: z.array(stringOrObjectId).default([]),
name: import_zod2.z.string().trim().optional(),
kind: import_zod2.z.nativeEnum(BaseBoxKind),
observation: import_zod2.z.string().trim().optional(),
coords: import_zod2.z.array(import_zod2.z.number()).length(2).refine(([lng, lat]) => lat >= -90 && lat <= 90 && lng >= -180 && lng <= 180)
});
var BaseBoxSchema = BaseModelSchema.merge(BaseBoxDataSchema);
// src/interface/model/BasePoint.ts
var import_zod3 = require("zod");
var BasePointKind = /* @__PURE__ */ ((BasePointKind2) => {
BasePointKind2["POLE"] = "Pole";
BasePointKind2["POINT"] = "Point";
BasePointKind2["JUNCTION_BOX"] = "JunctionBox";
return BasePointKind2;
})(BasePointKind || {});
var BasePointDataSchema = import_zod3.z.object({
adjacents: import_zod3.z.array(stringOrObjectId).default([]),
tags: import_zod3.z.array(stringOrObjectId).default([]),
kind: import_zod3.z.nativeEnum(BasePointKind),
coords: import_zod3.z.array(import_zod3.z.number()).length(2).refine(([lng, lat]) => lat >= -90 && lat <= 90 && lng >= -180 && lng <= 180)
});
var BasePointSchema = BaseModelSchema.merge(BasePointDataSchema);
// src/interface/model/Box.ts
var import_zod9 = require("zod");
// src/interface/model/Project.ts
var import_zod4 = require("zod");
var ProjectDataSchema = import_zod4.z.object({
name: import_zod4.z.string().trim(),
identifier: import_zod4.z.string().trim().optional(),
parents: import_zod4.z.array(
import_zod4.z.object({
project: stringOrObjectId
})
).default([]),
lat: import_zod4.z.number().default(0),
lng: import_zod4.z.number().default(0),
defaultPonPotency: import_zod4.z.number(),
defaultDropSize: import_zod4.z.number().optional(),
hasLogo: import_zod4.z.boolean().default(false),
drop: import_zod4.z.object({
type: import_zod4.z.object({
cableType: stringOrObjectId
}),
maxSize: import_zod4.z.number()
}),
area: import_zod4.z.object({
type: import_zod4.z.literal("Polygon"),
coordinates: import_zod4.z.array(import_zod4.z.array(import_zod4.z.tuple([import_zod4.z.number(), import_zod4.z.number()])))
})
});
var ProjectSchema = BaseModelSchema.merge(ProjectDataSchema);
var CreateProjectDTOSchema = ProjectDataSchema.omit({ hasLogo: true }).partial({ drop: true, defaultPonPotency: true, area: true, parents: true }).merge(import_zod4.z.object({ external_id: import_zod4.z.any().optional() }));
var UpdateProjectDTOSchema = ProjectDataSchema.merge(import_zod4.z.object({ external_id: import_zod4.z.any().optional() })).omit({ defaultDropSize: true, hasLogo: true }).partial();
// src/interface/model/Tag.ts
var import_zod5 = require("zod");
var TagDataSchema = import_zod5.z.object({
name: import_zod5.z.string().trim(),
allowedTypes: import_zod5.z.array(
import_zod5.z.enum([
"cable",
"box",
"pop",
"tower",
"property",
"client",
"building",
"pole",
"prospect",
"post",
"region",
"horizontalCondominium",
"pendency",
"antenna",
"sector",
"battery",
"radio",
"shelf",
"junctionBox",
"duct",
"splitter.ports"
])
)
});
var TagSchema = BaseModelSchema.merge(TagDataSchema);
var CreateTagDTOSchema = TagDataSchema.merge(import_zod5.z.object({ external_id: import_zod5.z.any().optional() }));
var UpdateTagDTOSchema = TagDataSchema.partial();
// src/interface/model/Color.ts
var import_zod6 = require("zod");
var ColorDataSchema = import_zod6.z.object({
color: import_zod6.z.string().trim(),
name: import_zod6.z.string().trim()
});
var ColorSchema = BaseModelSchema.merge(ColorDataSchema);
var CreateColorDTOSchema = ColorDataSchema.merge(import_zod6.z.object({ external_id: import_zod6.z.any().optional() }));
var UpdateColorDTOSchema = ColorDataSchema.partial();
// src/interface/model/BoxType.ts
var import_zod8 = require("zod");
// src/interface/model/BoxTemplate.ts
var import_zod7 = require("zod");
var DEFAULT_BOX_TEMPLATE_ID = "589de1d126324a2564a6c4d0";
var BoxTemplateDataSchema = import_zod7.z.object({
name: import_zod7.z.string().trim(),
structure: import_zod7.z.object({}),
positions: import_zod7.z.object({}),
topology: import_zod7.z.object({}),
description: import_zod7.z.string().optional()
});
var BoxTemplateSchema = BaseModelSchema.merge(BoxTemplateDataSchema);
var CreateBoxTemplateDTOSchema = BoxTemplateDataSchema.merge(import_zod7.z.object({ external_id: import_zod7.z.any().optional() }));
var UpdateBoxTemplateDTOSchema = BoxTemplateDataSchema.partial();
// src/interface/model/BoxType.ts
var BoxTypeDataSchema = import_zod8.z.object({
code: import_zod8.z.string().trim(),
brand: import_zod8.z.string().trim().optional(),
prefix: import_zod8.z.string(),
default_template: stringOrObjectId.default(DEFAULT_BOX_TEMPLATE_ID).optional(),
mold: import_zod8.z.string().trim().optional(),
default_level: import_zod8.z.number().optional(),
default_reserve: import_zod8.z.number().default(0),
description: import_zod8.z.string().trim().optional(),
config: import_zod8.z.object({
base: import_zod8.z.object({
color: import_zod8.z.string().default("#3388FFFF")
}),
regular: import_zod8.z.object({
fillColor: import_zod8.z.string().default("#3388FFFF")
}),
not_implanted: import_zod8.z.object({
fillColor: import_zod8.z.string().default("#FFA500A6")
}),
draft: import_zod8.z.object({
fillColor: import_zod8.z.string().default("#FFA500A6")
})
})
});
var BoxTypeSchema = BaseModelSchema.merge(BoxTypeDataSchema).omit({ default_template: true }).merge(
import_zod8.z.object({
default_template: stringOrObjectId.or(BoxTemplateSchema).optional()
})
);
var CreateBoxTypeDTOSchema = BoxTypeDataSchema.merge(
import_zod8.z.object({ external_id: import_zod8.z.any().optional(), prefix: import_zod8.z.string().default("").optional() })
);
var UpdateBoxTypeDTOSchema = BoxTypeDataSchema.merge(import_zod8.z.object({ external_id: import_zod8.z.any().optional() })).partial();
// src/interface/model/Box.ts
var BoxDataSchema = BaseBoxDataSchema.omit({ kind: true }).merge(
import_zod9.z.object({
kind: import_zod9.z.literal("Box" /* BOX */),
color: stringOrObjectId.optional(),
fill_color: stringOrObjectId.optional(),
name: import_zod9.z.string(),
address: import_zod9.z.string().optional(),
shared: import_zod9.z.boolean().default(false),
draft: import_zod9.z.boolean().default(false),
default_reserve: import_zod9.z.number().default(0),
hierarchyLevel: import_zod9.z.number(),
boxType: stringOrObjectId,
pole: stringOrObjectId,
certified: import_zod9.z.boolean().default(false),
implanted: import_zod9.z.boolean()
})
);
var BoxSchema = BaseModelSchema.merge(BoxDataSchema).merge(
import_zod9.z.object({
tags: import_zod9.z.array(stringOrObjectId.or(TagSchema)).default([]),
project: stringOrObjectId.or(ProjectSchema),
pole: stringOrObjectId.or(BasePointSchema),
color: stringOrObjectId.or(ColorSchema).optional(),
fill_color: stringOrObjectId.or(ColorSchema).optional(),
boxType: stringOrObjectId.or(BoxTypeSchema),
underground: import_zod9.z.boolean(),
// todo cable schema, mas cuidar com referência circular
cables: import_zod9.z.array(stringOrObjectId).default([])
})
);
var CreateBoxDTOSchema = BoxDataSchema.partial({
name: true,
pole: true,
kind: true
}).omit({ cables: true }).merge(
import_zod9.z.object({
max_distance: import_zod9.z.number().optional(),
external_id: import_zod9.z.any().optional(),
template: stringOrObjectId.optional(),
tags: import_zod9.z.array(stringOrObjectId).default([]).optional(),
shared: import_zod9.z.boolean().default(false).optional(),
draft: import_zod9.z.boolean().default(false).optional(),
certified: import_zod9.z.boolean().default(false).optional(),
default_reserve: import_zod9.z.number().default(0).optional()
})
);
var UpdateBoxDTOSchema = BoxDataSchema.merge(import_zod9.z.object({ external_id: import_zod9.z.any().optional() })).omit({
project: true,
kind: true,
cables: true
}).partial();
// src/interface/model/Building.ts
var import_zod11 = require("zod");
// src/interface/model/BuildingType.ts
var import_zod10 = require("zod");
var BuildingTypeDataSchema = import_zod10.z.object({
code: import_zod10.z.string().trim(),
prefix: import_zod10.z.string(),
default_template: stringOrObjectId.default(DEFAULT_BOX_TEMPLATE_ID).optional(),
description: import_zod10.z.string().trim().optional(),
config: import_zod10.z.object({
implanted: import_zod10.z.object({
color: import_zod10.z.string().default("#08641CFF")
}),
not_implanted: import_zod10.z.object({
color: import_zod10.z.string().default("#08641C73")
})
})
});
var BuildingTypeSchema = BaseModelSchema.merge(BuildingTypeDataSchema).omit({ default_template: true }).merge(
import_zod10.z.object({
default_template: stringOrObjectId.or(BoxTemplateSchema).optional()
})
);
var CreateBuildingTypeDTOSchema = BuildingTypeDataSchema.merge(
import_zod10.z.object({ external_id: import_zod10.z.any().optional(), prefix: import_zod10.z.string().default("").optional() })
);
var UpdateBuildingTypeDTOSchema = BuildingTypeDataSchema.merge(
import_zod10.z.object({ external_id: import_zod10.z.any().optional() })
).partial();
// src/interface/model/Building.ts
var BuildingDataSchema = BaseBoxDataSchema.omit({ kind: true }).merge(
import_zod11.z.object({
kind: import_zod11.z.literal("Building" /* BUILDING */),
name: import_zod11.z.string(),
address: import_zod11.z.string().trim().optional(),
implanted: import_zod11.z.boolean().default(true),
hasProblem: import_zod11.z.boolean().default(false),
buildingType: stringOrObjectId,
color: stringOrObjectId.optional()
})
);
var BuildingSchema = BaseModelSchema.merge(BuildingDataSchema).merge(
import_zod11.z.object({
tags: import_zod11.z.array(stringOrObjectId.or(TagSchema)).default([]),
project: stringOrObjectId.or(ProjectSchema),
cables: import_zod11.z.array(stringOrObjectId).default([]),
buildingType: stringOrObjectId.or(BuildingTypeSchema),
color: stringOrObjectId.or(ColorSchema).optional()
})
);
var CreateBuildingDTOSchema = BuildingDataSchema.partial({
name: true,
kind: true
}).omit({ cables: true, hasProblem: true }).merge(
import_zod11.z.object({
external_id: import_zod11.z.any().optional(),
tags: import_zod11.z.array(stringOrObjectId).default([]).optional(),
template: stringOrObjectId.optional()
})
);
var UpdateBuildingDTOSchema = BuildingDataSchema.merge(import_zod11.z.object({ external_id: import_zod11.z.any().optional() })).omit({
project: true,
kind: true,
cables: true,
hasProblem: true
}).partial();
// src/interface/model/Cable.ts
var import_zod13 = require("zod");
// src/interface/model/CableType.ts
var import_zod12 = require("zod");
var CableTypeDataSchema = import_zod12.z.object({
code: import_zod12.z.string().trim(),
brand: import_zod12.z.string().trim().optional(),
mold: import_zod12.z.string().trim().optional(),
default_level: import_zod12.z.number(),
description: import_zod12.z.string().trim().optional(),
config: import_zod12.z.object({
regular: import_zod12.z.object({
color: import_zod12.z.string().default("#3388FFFF"),
weight: import_zod12.z.number().default(6)
}),
not_implanted: import_zod12.z.object({
color: import_zod12.z.string().default("#FFA500A6"),
weight: import_zod12.z.number().default(6)
})
}),
fiberProfile: stringOrObjectId,
fiberNumber: import_zod12.z.number().min(1),
looseNumber: import_zod12.z.number().min(1),
base_loss: import_zod12.z.number()
});
var CableTypeSchema = BaseModelSchema.merge(CableTypeDataSchema);
var CreateCableTypeDTOSchema = CableTypeDataSchema.merge(import_zod12.z.object({ external_id: import_zod12.z.any().optional() }));
var UpdateCableTypeDTOSchema = CableTypeDataSchema.merge(import_zod12.z.object({ external_id: import_zod12.z.any().optional() })).partial();
// src/interface/model/Cable.ts
var CableDataSchema = import_zod13.z.object({
tags: import_zod13.z.array(stringOrObjectId).default([]),
project: stringOrObjectId,
color: stringOrObjectId.optional(),
cableType: stringOrObjectId,
boxA: stringOrObjectId,
boxB: stringOrObjectId,
ducts: import_zod13.z.array(import_zod13.z.object({ duct: stringOrObjectId, parent: stringOrObjectId })).default([]),
poles: import_zod13.z.array(
import_zod13.z.object({
id: stringOrObjectId,
reserve: import_zod13.z.number(),
from: stringOrObjectId.optional(),
into: stringOrObjectId.optional()
})
),
kind: import_zod13.z.union([import_zod13.z.literal("Cable"), import_zod13.z.literal("Drop")]),
index: import_zod13.z.number().optional(),
hierarchyLevel: import_zod13.z.number(),
name: import_zod13.z.string().trim().optional(),
fiberNumber: import_zod13.z.number(),
looseNumber: import_zod13.z.number(),
observation: import_zod13.z.string().trim().optional(),
orientationA: import_zod13.z.string(),
orientationB: import_zod13.z.string(),
implanted: import_zod13.z.boolean(),
length: import_zod13.z.number(),
altitude_length: import_zod13.z.number(),
ground_length: import_zod13.z.number(),
loss: import_zod13.z.number()
});
var CableSchema = BaseModelSchema.merge(CableDataSchema).merge(
import_zod13.z.object({
tags: import_zod13.z.array(stringOrObjectId.or(TagSchema)).default([]),
project: stringOrObjectId.or(ProjectSchema),
color: stringOrObjectId.or(ColorSchema).optional(),
cableType: stringOrObjectId.or(CableTypeSchema),
boxA: stringOrObjectId.or(BaseBoxSchema),
boxB: stringOrObjectId.or(BaseBoxSchema),
// todo fix type once we have duct schema
// ducts: z.array(z.object({ duct: stringOrObjectId, parent: stringOrObjectId })),
poles: import_zod13.z.array(
import_zod13.z.object({
id: stringOrObjectId.or(BasePointSchema),
reserve: import_zod13.z.number(),
// todo fix type once we have duct schema
from: stringOrObjectId.optional(),
into: stringOrObjectId.optional()
})
)
})
);
var CreateCableDTOSchema = CableDataSchema.omit({
ducts: true,
loss: true,
length: true,
ground_length: true,
altitude_length: true,
index: true,
fiberNumber: true,
looseNumber: true,
kind: true
}).merge(
import_zod13.z.object({
external_id: import_zod13.z.any().optional(),
boxA: import_zod13.z.union([stringOrObjectId, CreateBoxDTOSchema.omit({ coords: true, project: true, pole: true })]).nullish(),
boxB: import_zod13.z.union([stringOrObjectId, CreateBoxDTOSchema.omit({ coords: true, project: true, pole: true })]).nullish(),
poles: import_zod13.z.array(
import_zod13.z.union([
import_zod13.z.object({
id: stringOrObjectId,
reserve: import_zod13.z.number().optional(),
from: stringOrObjectId.optional(),
into: stringOrObjectId.optional()
}),
import_zod13.z.object({
lat: import_zod13.z.number(),
lng: import_zod13.z.number()
})
])
)
})
).partial({
orientationA: true,
orientationB: true,
tags: true
});
var UpdateCableDTOSchema = CreateCableDTOSchema.omit({ project: true }).partial();
// src/interface/model/CableStub.ts
var import_zod14 = require("zod");
var CableStubDataSchema = BaseBoxDataSchema.omit({ kind: true }).merge(
import_zod14.z.object({
kind: import_zod14.z.literal("CableStub" /* CABLE_STUB */)
})
);
var CableStubSchema = BaseModelSchema.merge(CableStubDataSchema);
// src/interface/model/Connector.ts
var import_zod18 = require("zod");
// src/interface/model/NetworkConnector.ts
var import_zod15 = require("zod");
var NetworkConnectorKind = /* @__PURE__ */ ((NetworkConnectorKind2) => {
NetworkConnectorKind2["SPLITTER"] = "Splitter";
NetworkConnectorKind2["DIO"] = "DIO";
NetworkConnectorKind2["FUSION"] = "Fusion";
NetworkConnectorKind2["CONNECTOR"] = "Connector";
NetworkConnectorKind2["PASSING"] = "Passing";
NetworkConnectorKind2["SWITCH"] = "Switch";
NetworkConnectorKind2["SHELF"] = "Shelf";
NetworkConnectorKind2["OLT"] = "OLT";
NetworkConnectorKind2["SLOT"] = "Slot";
NetworkConnectorKind2["PON"] = "PON";
return NetworkConnectorKind2;
})(NetworkConnectorKind || {});
var NetworkConnectorDataSchema = import_zod15.z.object({
kind: import_zod15.z.nativeEnum(NetworkConnectorKind),
connectables: import_zod15.z.union([
import_zod15.z.array(stringOrObjectId.nullable()),
import_zod15.z.object({
input: import_zod15.z.array(import_zod15.z.string().nullable()),
output: import_zod15.z.array(import_zod15.z.string().nullable())
})
]),
index: import_zod15.z.number().optional(),
label: import_zod15.z.string().default("").optional(),
attenuation: import_zod15.z.array(import_zod15.z.number()),
implanted: import_zod15.z.boolean().default(true),
isDrop: import_zod15.z.boolean().default(false),
parent: stringOrObjectId,
project: stringOrObjectId,
observation: import_zod15.z.string().optional(),
name: import_zod15.z.string(),
size: import_zod15.z.number().optional(),
shelf: stringOrObjectId.optional()
});
var NetworkConnectorSchema = BaseModelSchema.merge(NetworkConnectorDataSchema).merge(
import_zod15.z.object({
parent: import_zod15.z.union([stringOrObjectId, BaseBoxSchema]),
project: import_zod15.z.union([stringOrObjectId, ProjectSchema])
})
);
// src/interface/model/ConnectorType.ts
var import_zod16 = require("zod");
var ConnectorTypeDataSchema = import_zod16.z.object({
code: import_zod16.z.string().trim(),
brand: import_zod16.z.string().trim().nullish(),
mold: import_zod16.z.string().trim().nullish(),
description: import_zod16.z.string().trim().nullish(),
loss: import_zod16.z.number(),
isDrop: import_zod16.z.boolean()
});
var ConnectorTypeSchema = BaseModelSchema.merge(ConnectorTypeDataSchema);
var CreateConnectorTypeDTOSchema = ConnectorTypeDataSchema.merge(import_zod16.z.object({ external_id: import_zod16.z.any().optional() }));
var UpdateConnectorTypeDTOSchema = ConnectorTypeDataSchema.merge(
import_zod16.z.object({ external_id: import_zod16.z.any().optional() })
).partial();
// src/interface/model/NetworkConnectable.ts
var import_zod17 = require("zod");
var NetworkConnectableKind = /* @__PURE__ */ ((NetworkConnectableKind2) => {
NetworkConnectableKind2["FIBER"] = "Fiber";
NetworkConnectableKind2["CORD"] = "Cord";
return NetworkConnectableKind2;
})(NetworkConnectableKind || {});
var NetworkConnectableDataSchema = import_zod17.z.object({
kind: import_zod17.z.nativeEnum(NetworkConnectableKind),
connectors: import_zod17.z.array(stringOrObjectId).max(2),
parent: stringOrObjectId,
project: stringOrObjectId,
name: import_zod17.z.string().trim(),
observation: import_zod17.z.string().trim()
});
var NetworkConnectableSchema = BaseModelSchema.merge(NetworkConnectableDataSchema).merge(
import_zod17.z.object({
connectors: import_zod17.z.union([import_zod17.z.array(stringOrObjectId).max(2), import_zod17.z.array(NetworkConnectorSchema).max(2)]),
project: import_zod17.z.union([stringOrObjectId, ProjectSchema])
})
);
// src/interface/model/Connector.ts
var ConnectorDataSchema = NetworkConnectorDataSchema.merge(
import_zod18.z.object({
kind: import_zod18.z.literal("Connector" /* CONNECTOR */),
connectables: import_zod18.z.array(stringOrObjectId.nullable()),
connectorType: stringOrObjectId
})
);
var ConnectorSchema = NetworkConnectorSchema.merge(ConnectorDataSchema).merge(
import_zod18.z.object({
parent: import_zod18.z.union([stringOrObjectId, BaseBoxSchema]),
project: import_zod18.z.union([stringOrObjectId, ProjectSchema]),
connectorType: import_zod18.z.union([stringOrObjectId, ConnectorTypeSchema]),
connectables: import_zod18.z.union([import_zod18.z.array(stringOrObjectId.nullable()), import_zod18.z.array(NetworkConnectableSchema.nullable())]),
tags: import_zod18.z.array(stringOrObjectId.or(TagSchema)).default([])
})
);
var CreateConnectorDTOSchema = ConnectorDataSchema.partial({ attenuation: true, name: true }).omit({
project: true,
kind: true,
connectables: true,
isDrop: true
}).merge(import_zod18.z.object({ external_id: import_zod18.z.any().optional(), tags: import_zod18.z.array(stringOrObjectId).default([]).optional() }));
var UpdateConnectorDTOSchema = ConnectorDataSchema.omit({ kind: true, project: true, connectables: true }).merge(import_zod18.z.object({ external_id: import_zod18.z.any() })).partial();
// src/interface/model/Cord.ts
var import_zod19 = require("zod");
var CordDataSchema = NetworkConnectableDataSchema.merge(
import_zod19.z.object({
kind: import_zod19.z.literal("Cord" /* CORD */)
})
);
var CordSchema = NetworkConnectableSchema.merge(CordDataSchema).merge(
import_zod19.z.object({
parent: import_zod19.z.union([stringOrObjectId, BaseBoxSchema])
})
);
var CreateCordDTOSchema = CordDataSchema.omit({ kind: true, connectors: true, project: true }).merge(
import_zod19.z.object({ external_id: import_zod19.z.any().optional() })
);
var UpdateCordDTOSchema = CordDataSchema.omit({ parent: true, kind: true, connectors: true, project: true }).merge(import_zod19.z.object({ external_id: import_zod19.z.any() })).partial();
// src/interface/model/DIO.ts
var import_zod21 = require("zod");
// src/interface/model/DIOType.ts
var import_zod20 = require("zod");
var DIOTypeDataSchema = import_zod20.z.object({
code: import_zod20.z.string().trim(),
brand: import_zod20.z.string().trim().nullish(),
mold: import_zod20.z.string().trim().nullish(),
description: import_zod20.z.string().trim().nullish(),
ratio: import_zod20.z.number().min(1),
prefix: import_zod20.z.string().default("DIO "),
size: import_zod20.z.number().min(0).default(0),
loss: import_zod20.z.number().nullish(),
tray_number: import_zod20.z.number().min(0),
input_label: import_zod20.z.string(),
output_label: import_zod20.z.string()
});
var DIOTypeSchema = BaseModelSchema.merge(DIOTypeDataSchema);
var CreateDIOTypeDTOSchema = DIOTypeDataSchema.partial({
prefix: true,
input_label: true,
output_label: true
}).merge(import_zod20.z.object({ external_id: import_zod20.z.any().optional() }));
var UpdateDIOTypeDTOSchema = DIOTypeDataSchema.merge(import_zod20.z.object({ external_id: import_zod20.z.any().optional() })).partial();
// src/interface/model/DIO.ts
var DIODataSchema = NetworkConnectorDataSchema.merge(
import_zod21.z.object({
kind: import_zod21.z.literal("DIO" /* DIO */),
connectables: import_zod21.z.object({
input: import_zod21.z.array(import_zod21.z.string().nullable()),
output: import_zod21.z.array(import_zod21.z.string().nullable())
}),
dioType: stringOrObjectId,
observation: import_zod21.z.string().optional(),
tray_number: import_zod21.z.number(),
port_labels: import_zod21.z.array(import_zod21.z.string()),
tray_labels: import_zod21.z.array(import_zod21.z.string()),
input_label: import_zod21.z.array(import_zod21.z.string()),
output_label: import_zod21.z.array(import_zod21.z.string())
})
);
var DIOSchema = NetworkConnectorSchema.merge(DIODataSchema).merge(
import_zod21.z.object({
dioType: import_zod21.z.union([stringOrObjectId, DIOTypeSchema]),
// quando modelar shelf ela entra aqui
shelf: import_zod21.z.union([stringOrObjectId, NetworkConnectorSchema]).optional(),
tags: import_zod21.z.array(stringOrObjectId.or(TagSchema)).default([])
})
);
var CreateDIODTOSchema = DIODataSchema.partial({ attenuation: true, name: true }).omit({
tray_number: true,
kind: true,
connectables: true,
isDrop: true,
input_label: true,
output_label: true,
port_labels: true,
tray_labels: true
}).merge(import_zod21.z.object({ external_id: import_zod21.z.any().optional(), tags: import_zod21.z.array(stringOrObjectId).default([]).optional() }));
var UpdateDIODTOSchema = DIODataSchema.omit({ kind: true, project: true }).merge(import_zod21.z.object({ external_id: import_zod21.z.any() })).partial();
// src/interface/model/Duct.ts
var import_zod26 = require("zod");
// src/interface/model/DuctType.ts
var import_zod22 = require("zod");
var SubDuctStructureSchema = import_zod22.z.lazy(
() => import_zod22.z.object({
ductType: stringOrObjectId.nullish(),
color: stringOrObjectId.nullish(),
subDucts: import_zod22.z.array(SubDuctStructureSchema).nullish()
})
);
var DuctTypeDataSchema = import_zod22.z.object({
code: import_zod22.z.string().trim(),
brand: import_zod22.z.string().trim().nullish(),
mold: import_zod22.z.string().trim().nullish(),
description: import_zod22.z.string().trim().nullish(),
subDucts: import_zod22.z.array(SubDuctStructureSchema).nullish(),
config: import_zod22.z.object({
regular: import_zod22.z.object({
color: import_zod22.z.string().default("#000000"),
weight: import_zod22.z.number().default(10)
}),
notImplanted: import_zod22.z.object({
color: import_zod22.z.string().default("#606060A5"),
weight: import_zod22.z.number().default(10)
})
}).default({ regular: {}, notImplanted: {} })
});
var DuctTypeSchema = BaseModelSchema.merge(DuctTypeDataSchema);
var CreateDuctTypeDTOSchema = DuctTypeDataSchema.merge(import_zod22.z.object({ external_id: import_zod22.z.any().optional() }));
var UpdateDuctTypeDTOSchema = DuctTypeDataSchema.merge(import_zod22.z.object({ external_id: import_zod22.z.any().optional() })).partial();
// src/interface/model/JunctionBox.ts
var import_zod24 = require("zod");
// src/interface/model/JunctionBoxType.ts
var import_zod23 = require("zod");
var JunctionBoxTypeDataSchema = import_zod23.z.object({
code: import_zod23.z.string().trim(),
brand: import_zod23.z.string().trim().optional(),
mold: import_zod23.z.string().trim().optional(),
description: import_zod23.z.string().trim().optional(),
prefix: import_zod23.z.string(),
color: import_zod23.z.string().trim(),
systemDefault: import_zod23.z.boolean().default(false)
});
var JunctionBoxTypeSchema = BaseModelSchema.merge(JunctionBoxTypeDataSchema);
var CreateJunctionBoxTypeDTOSchema = JunctionBoxTypeDataSchema.merge(
import_zod23.z.object({ external_id: import_zod23.z.any().optional() })
).omit({ systemDefault: true });
var UpdateJunctionBoxTypeDTOSchema = JunctionBoxTypeDataSchema.omit({ systemDefault: true }).partial();
// src/interface/model/JunctionBox.ts
var JunctionBoxDataSchema = BasePointDataSchema.omit({ kind: true }).merge(
import_zod24.z.object({
name: import_zod24.z.string().trim(),
observation: import_zod24.z.string().trim().optional(),
kind: import_zod24.z.literal("JUNCTION_BOX"),
address: import_zod24.z.string().trim().optional(),
implanted: import_zod24.z.boolean().default(false),
project: stringOrObjectId,
junctionBoxType: stringOrObjectId,
color: stringOrObjectId.optional(),
typeColor: import_zod24.z.string(),
shared: import_zod24.z.boolean().default(false)
})
);
var JunctionBoxSchema = BaseModelSchema.merge(JunctionBoxDataSchema).merge(
import_zod24.z.object({
junctionBoxType: stringOrObjectId.or(JunctionBoxTypeSchema),
project: stringOrObjectId.or(ProjectSchema),
color: stringOrObjectId.or(ColorSchema).optional(),
tags: import_zod24.z.array(stringOrObjectId.or(TagSchema)).default([]),
adjacents: import_zod24.z.array(stringOrObjectId.or(BasePointSchema)).default([])
})
);
var CreateJunctionBoxDTOSchema = JunctionBoxDataSchema.omit({ kind: true, typeColor: true }).merge(
import_zod24.z.object({ external_id: import_zod24.z.any().optional() })
);
var UpdateJunctionBoxDTOSchema = JunctionBoxDataSchema.omit({ kind: true, typeColor: true, project: true }).partial();
// src/interface/model/Point.ts
var import_zod25 = require("zod");
var PointDataSchema = BasePointDataSchema.omit({ kind: true }).merge(
import_zod25.z.object({ kind: import_zod25.z.literal("Point" /* POINT */) })
);
var PointSchema = BaseModelSchema.merge(PointDataSchema).merge(
import_zod25.z.object({
adjacents: import_zod25.z.array(stringOrObjectId.or(BasePointSchema)).default([]),
tags: import_zod25.z.array(stringOrObjectId.or(TagSchema)).default([])
})
);
var CreatePointDTOSchema = PointDataSchema.omit({ kind: true, adjacents: true }).partial({ tags: true }).merge(import_zod25.z.object({ external_id: import_zod25.z.any().optional() }));
var UpdatePointDTOSchema = import_zod25.z.object({});
// src/interface/model/Duct.ts
var DuctDataSchema = import_zod26.z.object({
name: import_zod26.z.string().trim(),
observation: import_zod26.z.string().trim().nullish(),
implanted: import_zod26.z.boolean().default(true),
project: stringOrObjectId,
ductType: stringOrObjectId,
color: stringOrObjectId.nullish(),
length: import_zod26.z.number().positive(),
edgeA: stringOrObjectId,
edgeB: stringOrObjectId,
shared: import_zod26.z.boolean().default(false),
immediateParent: stringOrObjectId.nullish(),
parent: stringOrObjectId.nullish(),
points: import_zod26.z.array(stringOrObjectId),
tags: import_zod26.z.array(stringOrObjectId),
index: import_zod26.z.number().int().positive(),
typeColor: import_zod26.z.object({
regular: import_zod26.z.string().trim(),
notImplanted: import_zod26.z.string().trim()
})
});
var DuctSchema = BaseModelSchema.merge(DuctDataSchema).merge(
import_zod26.z.object({
project: import_zod26.z.union([stringOrObjectId, ProjectSchema]),
ductType: import_zod26.z.union([stringOrObjectId, DuctTypeSchema]),
edgeA: import_zod26.z.union([stringOrObjectId, JunctionBoxSchema]),
edgeB: import_zod26.z.union([stringOrObjectId, JunctionBoxSchema]),
points: import_zod26.z.union([import_zod26.z.array(stringOrObjectId), import_zod26.z.array(PointSchema)]),
tags: import_zod26.z.union([import_zod26.z.array(stringOrObjectId), import_zod26.z.array(TagSchema)])
})
);
var CreateDuctDTOSchema = DuctDataSchema.omit({
length: true,
immediateParent: true,
parent: true,
index: true,
typeColor: true
}).partial({ name: true, implanted: true }).merge(import_zod26.z.object({ external_id: import_zod26.z.any().optional(), subDucts: import_zod26.z.array(SubDuctStructureSchema).optional() }));
var UpdateDuctDTOSchema = DuctDataSchema.merge(import_zod26.z.object({ external_id: import_zod26.z.any().optional() })).partial();
// src/interface/model/Fiber.ts
var import_zod27 = require("zod");
var FiberDataSchema = NetworkConnectableDataSchema.merge(
import_zod27.z.object({
kind: import_zod27.z.literal("Fiber" /* FIBER */),
isDrop: import_zod27.z.boolean(),
fiberNumber: import_zod27.z.number()
})
);
var FiberSchema = NetworkConnectableSchema.merge(FiberDataSchema).merge(
import_zod27.z.object({
parent: import_zod27.z.union([stringOrObjectId, CableSchema])
})
);
var UpdateFiberDTOSchema = FiberDataSchema.omit({
kind: true,
project: true,
connectors: true,
fiberNumber: true,
isDrop: true,
parent: true
}).partial();
// src/interface/model/FiberProfile.ts
var import_zod28 = require("zod");
var FiberProfileDataSchema = import_zod28.z.object({
name: import_zod28.z.string().trim(),
defaultFiberColor: import_zod28.z.string().default("white"),
defaultTubeColor: import_zod28.z.string().default("white"),
fibers: import_zod28.z.array(import_zod28.z.object({ color: import_zod28.z.string().trim() })),
tubes: import_zod28.z.array(import_zod28.z.object({ color: import_zod28.z.string().trim() }))
});
var FiberProfileSchema = BaseModelSchema.merge(FiberProfileDataSchema);
var CreateFiberProfileDTOSchema = FiberProfileDataSchema.merge(import_zod28.z.object({ external_id: import_zod28.z.any().optional() })).partial(
{ defaultFiberColor: true, defaultTubeColor: true }
);
var UpdateFiberProfileDTOSchema = FiberProfileDataSchema.merge(
import_zod28.z.object({ external_id: import_zod28.z.any().optional() })
).partial();
// src/interface/model/FTTHClient.ts
var import_zod29 = require("zod");
var FTTHClientStatus = /* @__PURE__ */ ((FTTHClientStatus2) => {
FTTHClientStatus2["OK"] = "OK";
FTTHClientStatus2["ERROR"] = "ERROR";
return FTTHClientStatus2;
})(FTTHClientStatus || {});
var FTTHClientDataSchema = import_zod29.z.object({
tags: import_zod29.z.array(stringOrObjectId).default([]),
code: import_zod29.z.string().trim(),
name: import_zod29.z.string().trim().optional(),
observation: import_zod29.z.string().trim().optional(),
implanted: import_zod29.z.boolean().default(false),
certified: import_zod29.z.boolean().default(false),
status: import_zod29.z.nativeEnum(FTTHClientStatus).default("OK" /* OK */),
cpe: import_zod29.z.any().optional(),
onu: import_zod29.z.object({
user_PPPoE: import_zod29.z.string().trim(),
serial_number: import_zod29.z.string().trim(),
mac_address: import_zod29.z.string().trim()
}).default({
user_PPPoE: "",
serial_number: "",
mac_address: ""
})
});
var FTTHClientSchema = BaseModelSchema.merge(FTTHClientDataSchema).merge(
import_zod29.z.object({
kind: import_zod29.z.literal("FTTHClient"),
tags: import_zod29.z.union([import_zod29.z.array(stringOrObjectId), import_zod29.z.array(TagSchema)])
})
);
var CreateFTTHClientDTOSchema = FTTHClientDataSchema.partial({
tags: true,
code: true,
certified: true,
onu: true,
status: true,
cpe: true
}).merge(import_zod29.z.object({ external_id: import_zod29.z.any().optional() }));
var UpdateFTTHClientDTOSchema = FTTHClientDataSchema.merge(import_zod29.z.object({ external_id: import_zod29.z.any().optional() })).partial();
// src/interface/model/Fusion.ts
var import_zod31 = require("zod");
// src/interface/model/FusionType.ts
var import_zod30 = require("zod");
var FusionTypeDataSchema = import_zod30.z.object({
code: import_zod30.z.string().trim(),
loss: import_zod30.z.number(),
isDrop: import_zod30.z.boolean()
});
var FusionTypeSchema = BaseModelSchema.merge(FusionTypeDataSchema);
var CreateFusionTypeDTOSchema = FusionTypeDataSchema.merge(import_zod30.z.object({ external_id: import_zod30.z.any().optional() }));
var UpdateFusionTypeDTOSchema = FusionTypeDataSchema.merge(import_zod30.z.object({ external_id: import_zod30.z.any().optional() })).partial();
// src/interface/model/Fusion.ts
var FusionDataSchema = NetworkConnectorDataSchema.merge(
import_zod31.z.object({
kind: import_zod31.z.literal("Fusion" /* FUSION */),
connectables: import_zod31.z.array(stringOrObjectId.nullable()),
fusionType: stringOrObjectId
})
);
var FusionSchema = NetworkConnectorSchema.merge(FusionDataSchema).merge(
import_zod31.z.object({
fusionType: import_zod31.z.union([stringOrObjectId, FusionTypeSchema]),
connectables: import_zod31.z.union([import_zod31.z.array(stringOrObjectId.nullable()), import_zod31.z.array(NetworkConnectableSchema.nullable())]),
tags: import_zod31.z.array(stringOrObjectId.or(TagSchema)).default([])
})
);
var CreateFusionDTOSchema = FusionDataSchema.partial({ attenuation: true }).omit({
kind: true,
connectables: true,
isDrop: true
}).merge(import_zod31.z.object({ external_id: import_zod31.z.any().optional(), tags: import_zod31.z.array(stringOrObjectId).default([]).optional() }));
var UpdateFusionDTOSchema = FusionDataSchema.omit({ kind: true, project: true, connectables: true }).merge(import_zod31.z.object({ external_id: import_zod31.z.any() })).partial({ name: true });
// src/interface/model/File.ts
var import_zod32 = require("zod");
var FileDataSchema = import_zod32.z.object({
name: import_zod32.z.string().trim().nullish(),
contentType: import_zod32.z.string().trim().nullish()
});
var FileSchema = BaseModelSchema.merge(FileDataSchema);
// src/interface/model/HorizontalCondominium.ts
var import_zod33 = require("zod");
var HorizontalCondominiumDataSchema = import_zod33.z.object({
polygon: import_zod33.z.object({
type: import_zod33.z.enum(["Polygon"]),
coordinates: import_zod33.z.array(import_zod33.z.array(coordinates))
}),
project: stringOrObjectId,
name: import_zod33.z.string().trim().nullish(),
observation: import_zod33.z.string().nullish(),
address: import_zod33.z.string().nullish(),
color: import_zod33.z.string().nullish(),
tags: import_zod33.z.array(stringOrObjectId)
});
var HorizontalCondominiumSchema = BaseModelSchema.merge(HorizontalCondominiumDataSchema).merge(
import_zod33.z.object({
project: import_zod33.z.union([stringOrObjectId, ProjectSchema]),
tags: import_zod33.z.array(stringOrObjectId.or(TagSchema)).default([])
})
);
var CreateHorizontalCondominiumDTOSchema = HorizontalCondominiumDataSchema.merge(
import_zod33.z.object({ external_id: import_zod33.z.any().optional() })
);
var UpdateHorizontalCondominiumDTOSchema = HorizontalCondominiumDataSchema.partial().merge(
import_zod33.z.object({ external_id: import_zod33.z.any() })
);
// src/interface/model/Passing.ts
var import_zod34 = require("zod");
var PassingDataSchema = NetworkConnectorDataSchema.merge(
import_zod34.z.object({
kind: import_zod34.z.literal("Passing" /* PASSING */),
connectables: import_zod34.z.array(stringOrObjectId.nullable()),
name: import_zod34.z.string().optional()
})
);
var PassingSchema = NetworkConnectorSchema.merge(PassingDataSchema).merge(
import_zod34.z.object({
connectables: import_zod34.z.union([import_zod34.z.array(stringOrObjec