samva 0.16.0 → 0.17.0

package/dist/templates-DZomxsG7.js

@@ -0,0 +1,2289 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { $t as UserId, D as Cursor, Ft as RenderLocale, Gt as TemplateInputContractId, Ht as SuccessResponse, It as RenderTimeZone, Jt as UnauthorizedError, K as ForbiddenError, Kt as TemplatePublicationId, Lt as ResourceNotFoundError, Mt as OrganizationId, T as CreateTemplatePayload, Ut as TemplateFromDefault, Wt as TemplateId, Y as InternalError, Zt as UpdateTemplatePayload, d as BrandAssets, en as ValidationError, et as JsonValue, f as BrandFooter, m as ConflictError, q as GatewayTimeoutError, s as ApiKeySecurityMiddleware } from "./client-DOzUrdTE.js";
+import { n as forGroup } from "./operation-n_IYgNVK.js";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/templates.ts
+const TemplateProjectId = /* @__PURE__ */ Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^tproj_[0-9a-hjkmnp-tv-z]{16,24}$", "u")).annotate({
+	expected: "a string matching the RegExp ^tproj_[0-9a-hjkmnp-tv-z]{16,24}$",
+	identifier: "TemplateProjectId"
+})).pipe(Schema.brand("TemplateProjectId"));
+const TemplatePublicationBrand = /* @__PURE__ */ Schema.Struct({
+	slug: Schema.String.annotate({ description: "The brand the publication imports." }).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$" })),
+	digest: Schema.String.annotate({ description: "The brand's digest when the publication was built." }),
+	stale: Schema.Boolean.annotate({ description: "Whether the brand has changed since this publication was built. Publishing the same commit again picks up the change." })
+}).annotate({ identifier: "TemplatePublicationBrand" });
+const TemplateFamilyId = /* @__PURE__ */ Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^tfam_[0-9a-hjkmnp-tv-z]{16,24}$", "u")).annotate({
+	expected: "a string matching the RegExp ^tfam_[0-9a-hjkmnp-tv-z]{16,24}$",
+	identifier: "TemplateFamilyId"
+})).pipe(Schema.brand("TemplateFamilyId"));
+const VersionCursor = /* @__PURE__ */ Schema.String.annotate({ identifier: "VersionCursor" });
+const BrandFooterBlock = /* @__PURE__ */ Schema.Struct({
+	html: Schema.String,
+	text: Schema.String
+}).annotate({ identifier: "BrandFooterBlock" });
+const TemplatePublicationRender = /* @__PURE__ */ Schema.Struct({
+	subject: Schema.String,
+	preheader: Schema.optionalKey(Schema.String),
+	html: Schema.String.check(Schema.isMaxCodePoints(2097152).annotate({ expected: "a string with at most 2097152 code points" })).check(Schema.isMaxLength(2097152).annotate({ expected: "a value with a length of at most 2097152" })),
+	text: Schema.String.check(Schema.isMaxCodePoints(2097152).annotate({ expected: "a string with at most 2097152 code points" })).check(Schema.isMaxLength(2097152).annotate({ expected: "a value with a length of at most 2097152" }))
+}).annotate({ identifier: "TemplatePublicationRender" });
+const TemplateInputContractPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(Schema.Struct({
+		id: TemplateInputContractId,
+		organizationId: OrganizationId,
+		templateId: TemplateId,
+		version: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+		validationDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+		schema: Schema.Record(Schema.String, JsonValue),
+		createdAt: Schema.String
+	})),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "TemplateInputContractPage" });
+const TemplateFamilyMember = /* @__PURE__ */ Schema.Struct({
+	id: TemplateId,
+	name: Schema.String,
+	slug: Schema.String,
+	channel: Schema.Literal("email"),
+	status: Schema.Union([
+		Schema.Literal("draft"),
+		Schema.Literal("pending"),
+		Schema.Literal("approved"),
+		Schema.Literal("published"),
+		Schema.Literal("rejected"),
+		Schema.Literal("archived")
+	]),
+	isActive: Schema.Boolean,
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+}).annotate({ identifier: "TemplateFamilyMember" });
+const TemplateSummary = /* @__PURE__ */ Schema.Struct({
+	id: TemplateId,
+	slug: Schema.String,
+	name: Schema.String,
+	channel: Schema.Literal("email"),
+	projectId: TemplateProjectId,
+	entryPath: Schema.String.check(Schema.isMaxCodePoints(1024).annotate({ expected: "a string with at most 1024 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$", "u")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$" })).check(Schema.isMaxLength(1024).annotate({ expected: "a value with a length of at most 1024" })),
+	status: Schema.Union([
+		Schema.Literal("draft"),
+		Schema.Literal("pending"),
+		Schema.Literal("approved"),
+		Schema.Literal("published"),
+		Schema.Literal("rejected"),
+		Schema.Literal("archived")
+	]),
+	isActive: Schema.Boolean,
+	publishedAt: Schema.Union([Schema.String, Schema.Null]),
+	brand: Schema.Union([TemplatePublicationBrand, Schema.Null]),
+	fromDefault: Schema.Union([TemplateFromDefault, Schema.Null]),
+	usageCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	lastUsedAt: Schema.Union([Schema.String, Schema.Null]),
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+}).annotate({ identifier: "TemplateSummary" });
+const Template = /* @__PURE__ */ Schema.Struct({
+	id: TemplateId,
+	slug: Schema.String,
+	name: Schema.String,
+	channel: Schema.Literal("email"),
+	projectId: TemplateProjectId,
+	entryPath: Schema.String.check(Schema.isMaxCodePoints(1024).annotate({ expected: "a string with at most 1024 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$", "u")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$" })).check(Schema.isMaxLength(1024).annotate({ expected: "a value with a length of at most 1024" })),
+	status: Schema.Union([
+		Schema.Literal("draft"),
+		Schema.Literal("pending"),
+		Schema.Literal("approved"),
+		Schema.Literal("published"),
+		Schema.Literal("rejected"),
+		Schema.Literal("archived")
+	]),
+	isActive: Schema.Boolean,
+	publishedAt: Schema.Union([Schema.String, Schema.Null]),
+	brand: Schema.Union([TemplatePublicationBrand, Schema.Null]),
+	fromDefault: Schema.Union([TemplateFromDefault, Schema.Null]),
+	usageCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	lastUsedAt: Schema.Union([Schema.String, Schema.Null]),
+	createdAt: Schema.String,
+	updatedAt: Schema.String,
+	familyId: Schema.Union([TemplateFamilyId, Schema.Null]),
+	description: Schema.Union([Schema.String, Schema.Null]),
+	category: Schema.Union([Schema.Union([
+		Schema.Literal("transactional"),
+		Schema.Literal("marketing"),
+		Schema.Literal("support"),
+		Schema.Literal("notification"),
+		Schema.Literal("verification"),
+		Schema.Literal("reminder"),
+		Schema.Literal("alert")
+	]), Schema.Null]),
+	replyToDefault: Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+	trackingDefault: Schema.Union([Schema.Struct({
+		opens: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Null])),
+		clicks: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Null]))
+	}), Schema.Null]),
+	email: Schema.Union([Schema.Struct({
+		subject: Schema.String,
+		preheader: Schema.Union([Schema.String, Schema.Null]),
+		headers: Schema.Union([Schema.Record(Schema.String, Schema.String), Schema.Null])
+	}), Schema.Null]),
+	publicationId: Schema.Union([TemplatePublicationId, Schema.Null]),
+	inputContractId: Schema.Union([TemplateInputContractId, Schema.Null]),
+	inputSchema: Schema.Union([Schema.Record(Schema.String, JsonValue), Schema.Null])
+}).annotate({ identifier: "Template" });
+const BrandRenderedFooter = /* @__PURE__ */ Schema.Struct({
+	withUnsubscribe: BrandFooterBlock,
+	withoutUnsubscribe: BrandFooterBlock
+}).annotate({ identifier: "BrandRenderedFooter" });
+const TemplateFamily = /* @__PURE__ */ Schema.Struct({
+	id: TemplateFamilyId,
+	name: Schema.String,
+	members: Schema.Array(TemplateFamilyMember),
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+}).annotate({ identifier: "TemplateFamily" });
+const TemplatePage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(TemplateSummary),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "TemplatePage" });
+const TemplateFamilyPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(TemplateFamily),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "TemplateFamilyPage" });
+const TemplatesListQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null])),
+	category: Schema.optionalKey(Schema.Union([Schema.Union([
+		Schema.Literal("transactional"),
+		Schema.Literal("marketing"),
+		Schema.Literal("support"),
+		Schema.Literal("notification"),
+		Schema.Literal("verification"),
+		Schema.Literal("reminder"),
+		Schema.Literal("alert")
+	]), Schema.Null])),
+	channel: Schema.optionalKey(Schema.Union([Schema.Literal("email"), Schema.Null])),
+	status: Schema.optionalKey(Schema.Union([Schema.Union([
+		Schema.Literal("draft"),
+		Schema.Literal("pending"),
+		Schema.Literal("approved"),
+		Schema.Literal("published"),
+		Schema.Literal("rejected"),
+		Schema.Literal("archived")
+	]), Schema.Null])),
+	search: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	projectId: Schema.optionalKey(Schema.Union([TemplateProjectId, Schema.Null]))
+});
+const TemplatesList200 = TemplatePage;
+const TemplatesList401 = UnauthorizedError;
+const TemplatesList403 = ForbiddenError;
+const TemplatesList422 = ValidationError;
+const TemplatesList500 = InternalError;
+const TemplatesList504 = GatewayTimeoutError;
+const TemplatesCreateRequestJson = /* @__PURE__ */ Schema.Struct({
+	name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(200).annotate({ expected: "a string with at most 200 code points" })).check(Schema.isMaxLength(200).annotate({ expected: "a value with a length of at most 200" })),
+	projectName: Schema.optionalKey(Schema.Union([Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(200).annotate({ expected: "a string with at most 200 code points" })).check(Schema.isMaxLength(200).annotate({ expected: "a value with a length of at most 200" })), Schema.Null])),
+	slug: Schema.optionalKey(Schema.Union([Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?=.{1,100}$)[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^(?=.{1,100}$)[a-z0-9]+(?:-[a-z0-9]+)*$" })), Schema.Null])),
+	galleryTemplateId: Schema.optionalKey(Schema.Union([Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })), Schema.Null])),
+	useBrand: Schema.optionalKey(Schema.Union([Schema.Boolean.annotate({ description: "With `galleryTemplateId`: whether the new project's `theme.css` imports the organization's default brand (`@import \"samva:brand\";`) over the starter's look. Defaults to false." }), Schema.Null])),
+	description: Schema.optionalKey(Schema.Union([Schema.Union([Schema.String, Schema.Null]), Schema.Null])),
+	category: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Union([
+		Schema.Literal("transactional"),
+		Schema.Literal("marketing"),
+		Schema.Literal("support"),
+		Schema.Literal("notification"),
+		Schema.Literal("verification"),
+		Schema.Literal("reminder"),
+		Schema.Literal("alert")
+	]), Schema.Null]), Schema.Null])),
+	isActive: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Null])),
+	idempotencyKey: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" }))
+});
+const TemplatesCreate201 = Template;
+const TemplatesCreate401 = UnauthorizedError;
+const TemplatesCreate403 = ForbiddenError;
+const TemplatesCreate409 = ConflictError;
+const TemplatesCreate422 = ValidationError;
+const TemplatesCreate500 = InternalError;
+const TemplatesCreate504 = GatewayTimeoutError;
+const TemplatesGetByIdPathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesGetById200 = Template;
+const TemplatesGetById401 = UnauthorizedError;
+const TemplatesGetById403 = ForbiddenError;
+const TemplatesGetById404 = ResourceNotFoundError;
+const TemplatesGetById422 = ValidationError;
+const TemplatesGetById500 = InternalError;
+const TemplatesGetById504 = GatewayTimeoutError;
+const TemplatesRemovePathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesRemove200 = SuccessResponse;
+const TemplatesRemove401 = UnauthorizedError;
+const TemplatesRemove403 = ForbiddenError;
+const TemplatesRemove404 = ResourceNotFoundError;
+const TemplatesRemove422 = ValidationError;
+const TemplatesRemove500 = InternalError;
+const TemplatesRemove504 = GatewayTimeoutError;
+const TemplatesUpdatePathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesUpdateRequestJson = /* @__PURE__ */ Schema.Struct({ data: Schema.Struct({
+	name: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	slug: Schema.optionalKey(Schema.Union([Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?=.{1,100}$)[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^(?=.{1,100}$)[a-z0-9]+(?:-[a-z0-9]+)*$" })), Schema.Null])),
+	entryPath: Schema.optionalKey(Schema.Union([Schema.String.check(Schema.isMaxCodePoints(1024).annotate({ expected: "a string with at most 1024 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$", "u")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$" })).check(Schema.isMaxLength(1024).annotate({ expected: "a value with a length of at most 1024" })), Schema.Null])),
+	description: Schema.optionalKey(Schema.Union([Schema.Union([Schema.String, Schema.Null]), Schema.Null])),
+	category: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Union([
+		Schema.Literal("transactional"),
+		Schema.Literal("marketing"),
+		Schema.Literal("support"),
+		Schema.Literal("notification"),
+		Schema.Literal("verification"),
+		Schema.Literal("reminder"),
+		Schema.Literal("alert")
+	]), Schema.Null]), Schema.Null])),
+	fromDefault: Schema.optionalKey(Schema.Union([Schema.Union([TemplateFromDefault, Schema.Null]), Schema.Null])),
+	replyToDefault: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Array(Schema.String), Schema.Null]), Schema.Null])),
+	isActive: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Null]))
+}) });
+const TemplatesUpdate200 = Template;
+const TemplatesUpdate401 = UnauthorizedError;
+const TemplatesUpdate403 = ForbiddenError;
+const TemplatesUpdate404 = ResourceNotFoundError;
+const TemplatesUpdate409 = ConflictError;
+const TemplatesUpdate422 = ValidationError;
+const TemplatesUpdate500 = InternalError;
+const TemplatesUpdate504 = GatewayTimeoutError;
+const TemplatesListInputContractsPathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesListInputContractsQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([VersionCursor, Schema.Null]))
+});
+const TemplatesListInputContracts200 = TemplateInputContractPage;
+const TemplatesListInputContracts401 = UnauthorizedError;
+const TemplatesListInputContracts403 = ForbiddenError;
+const TemplatesListInputContracts404 = ResourceNotFoundError;
+const TemplatesListInputContracts422 = ValidationError;
+const TemplatesListInputContracts500 = InternalError;
+const TemplatesListInputContracts504 = GatewayTimeoutError;
+const TemplatesGetInputContractPathParams = /* @__PURE__ */ Schema.Struct({
+	id: TemplateId,
+	inputContractId: TemplateInputContractId
+});
+const TemplatesGetInputContract200 = /* @__PURE__ */ Schema.Struct({
+	id: TemplateInputContractId,
+	organizationId: OrganizationId,
+	templateId: TemplateId,
+	version: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+	validationDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+	schema: Schema.Record(Schema.String, JsonValue),
+	createdAt: Schema.String
+});
+const TemplatesGetInputContract401 = UnauthorizedError;
+const TemplatesGetInputContract403 = ForbiddenError;
+const TemplatesGetInputContract404 = ResourceNotFoundError;
+const TemplatesGetInputContract422 = ValidationError;
+const TemplatesGetInputContract500 = InternalError;
+const TemplatesGetInputContract504 = GatewayTimeoutError;
+const TemplatesPublishPathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesPublishRequestJson = /* @__PURE__ */ Schema.Struct({
+	projectId: TemplateProjectId,
+	commitSha: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+	entryPath: Schema.String.check(Schema.isMaxCodePoints(1024).annotate({ expected: "a string with at most 1024 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$", "u")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$" })).check(Schema.isMaxLength(1024).annotate({ expected: "a value with a length of at most 1024" })),
+	expectedWorkspaceRevision: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+	ifCurrentPublicationId: Schema.optionalKey(Schema.Union([TemplatePublicationId, Schema.Null]))
+});
+const TemplatesPublish201 = /* @__PURE__ */ Schema.Struct({
+	id: TemplatePublicationId,
+	organizationId: OrganizationId,
+	projectId: TemplateProjectId,
+	templateId: TemplateId,
+	inputContractId: TemplateInputContractId,
+	commitSha: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+	treeSha: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+	entryPath: Schema.String.check(Schema.isMaxCodePoints(1024).annotate({ expected: "a string with at most 1024 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$", "u")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$" })).check(Schema.isMaxLength(1024).annotate({ expected: "a value with a length of at most 1024" })),
+	buildIdentity: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+	manifest: Schema.Struct({
+		templateKey: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+		ir: Schema.Struct({
+			version: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+			bytes: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" }))
+		}),
+		compiler: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+		input: Schema.Struct({
+			schemaDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+			contractDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" }))
+		}),
+		assets: Schema.Struct({
+			base: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^https?:\\/\\/", "u")).annotate({ expected: "a string matching the RegExp ^https?:\\/\\/" })),
+			entries: Schema.Array(Schema.Struct({
+				path: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(1024).annotate({ expected: "a string with at most 1024 code points" })).check(Schema.isMaxLength(1024).annotate({ expected: "a value with a length of at most 1024" })),
+				fileName: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}(?:\\.[A-Za-z0-9]+)?$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}(?:\\.[A-Za-z0-9]+)?$" })),
+				digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+				bytes: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+				contentType: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+				url: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^https?:\\/\\/", "u")).annotate({ expected: "a string matching the RegExp ^https?:\\/\\/" }))
+			})).check(Schema.isMaxLength(32).annotate({ expected: "a value with a length of at most 32" }))
+		}),
+		source: Schema.Struct({
+			commitSha: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+			treeSha: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+			entryPath: Schema.String.check(Schema.isMaxCodePoints(1024).annotate({ expected: "a string with at most 1024 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$", "u")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$" })).check(Schema.isMaxLength(1024).annotate({ expected: "a value with a length of at most 1024" })),
+			treeDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" }))
+		}),
+		brand: Schema.optionalKey(Schema.Struct({
+			slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$" })),
+			css: Schema.String,
+			assets: BrandAssets,
+			footer: BrandFooter,
+			renderedFooter: BrandRenderedFooter,
+			digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+			rendersFooter: Schema.Union([
+				Schema.Literal("every"),
+				Schema.Literal("some"),
+				Schema.Literal("none")
+			])
+		}))
+	}),
+	ir: Schema.Struct({
+		key: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+		digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" }))
+	}),
+	assets: Schema.Array(Schema.Struct({
+		path: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(1024).annotate({ expected: "a string with at most 1024 code points" })).check(Schema.isMaxLength(1024).annotate({ expected: "a value with a length of at most 1024" })),
+		fileName: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}(?:\\.[A-Za-z0-9]+)?$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}(?:\\.[A-Za-z0-9]+)?$" })),
+		digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+		bytes: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+		contentType: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+		url: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^https?:\\/\\/", "u")).annotate({ expected: "a string matching the RegExp ^https?:\\/\\/" }))
+	})),
+	warnings: Schema.Array(Schema.Struct({
+		code: Schema.String,
+		severity: Schema.Union([
+			Schema.Literal("error"),
+			Schema.Literal("warning"),
+			Schema.Literal("info")
+		]),
+		message: Schema.String,
+		origins: Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		})),
+		clients: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		notes: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		provenance: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		fixtures: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		occurrences: Schema.optionalKey(Schema.Union([Schema.Array(Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		}))), Schema.Null])),
+		compatibility: Schema.optionalKey(Schema.Union([Schema.Struct({
+			assessment: Schema.Union([
+				Schema.Literal("risk"),
+				Schema.Literal("degradation"),
+				Schema.Literal("unverified"),
+				Schema.Literal("not-applicable")
+			]),
+			title: Schema.String
+		}), Schema.Null]))
+	})),
+	incompatibilities: Schema.Array(Schema.Struct({
+		code: Schema.String,
+		severity: Schema.Union([
+			Schema.Literal("error"),
+			Schema.Literal("warning"),
+			Schema.Literal("info")
+		]),
+		message: Schema.String,
+		origins: Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		})),
+		clients: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		notes: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		provenance: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		fixtures: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		occurrences: Schema.optionalKey(Schema.Union([Schema.Array(Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		}))), Schema.Null])),
+		compatibility: Schema.optionalKey(Schema.Union([Schema.Struct({
+			assessment: Schema.Union([
+				Schema.Literal("risk"),
+				Schema.Literal("degradation"),
+				Schema.Literal("unverified"),
+				Schema.Literal("not-applicable")
+			]),
+			title: Schema.String
+		}), Schema.Null]))
+	})),
+	status: Schema.String,
+	publishedAt: Schema.String,
+	publishedBy: Schema.Union([Schema.String, Schema.Null]),
+	createdAt: Schema.String
+});
+const TemplatesPublish401 = UnauthorizedError;
+const TemplatesPublish403 = ForbiddenError;
+const TemplatesPublish404 = ResourceNotFoundError;
+const TemplatesPublish409 = ConflictError;
+const TemplatesPublish422 = ValidationError;
+const TemplatesPublish500 = InternalError;
+const TemplatesPublish504 = GatewayTimeoutError;
+const TemplatesGetPublicationPathParams = /* @__PURE__ */ Schema.Struct({
+	id: TemplateId,
+	publicationId: TemplatePublicationId
+});
+const TemplatesGetPublication200 = /* @__PURE__ */ Schema.Struct({
+	id: TemplatePublicationId,
+	organizationId: OrganizationId,
+	projectId: TemplateProjectId,
+	templateId: TemplateId,
+	inputContractId: TemplateInputContractId,
+	commitSha: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+	treeSha: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+	entryPath: Schema.String.check(Schema.isMaxCodePoints(1024).annotate({ expected: "a string with at most 1024 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$", "u")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$" })).check(Schema.isMaxLength(1024).annotate({ expected: "a value with a length of at most 1024" })),
+	buildIdentity: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+	manifest: Schema.Struct({
+		templateKey: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+		ir: Schema.Struct({
+			version: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+			bytes: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" }))
+		}),
+		compiler: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+		input: Schema.Struct({
+			schemaDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+			contractDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" }))
+		}),
+		assets: Schema.Struct({
+			base: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^https?:\\/\\/", "u")).annotate({ expected: "a string matching the RegExp ^https?:\\/\\/" })),
+			entries: Schema.Array(Schema.Struct({
+				path: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(1024).annotate({ expected: "a string with at most 1024 code points" })).check(Schema.isMaxLength(1024).annotate({ expected: "a value with a length of at most 1024" })),
+				fileName: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}(?:\\.[A-Za-z0-9]+)?$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}(?:\\.[A-Za-z0-9]+)?$" })),
+				digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+				bytes: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+				contentType: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+				url: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^https?:\\/\\/", "u")).annotate({ expected: "a string matching the RegExp ^https?:\\/\\/" }))
+			})).check(Schema.isMaxLength(32).annotate({ expected: "a value with a length of at most 32" }))
+		}),
+		source: Schema.Struct({
+			commitSha: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+			treeSha: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+			entryPath: Schema.String.check(Schema.isMaxCodePoints(1024).annotate({ expected: "a string with at most 1024 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$", "u")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$" })).check(Schema.isMaxLength(1024).annotate({ expected: "a value with a length of at most 1024" })),
+			treeDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" }))
+		}),
+		brand: Schema.optionalKey(Schema.Struct({
+			slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$" })),
+			css: Schema.String,
+			assets: BrandAssets,
+			footer: BrandFooter,
+			renderedFooter: BrandRenderedFooter,
+			digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+			rendersFooter: Schema.Union([
+				Schema.Literal("every"),
+				Schema.Literal("some"),
+				Schema.Literal("none")
+			])
+		}))
+	}),
+	ir: Schema.Struct({
+		key: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+		digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" }))
+	}),
+	assets: Schema.Array(Schema.Struct({
+		path: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(1024).annotate({ expected: "a string with at most 1024 code points" })).check(Schema.isMaxLength(1024).annotate({ expected: "a value with a length of at most 1024" })),
+		fileName: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}(?:\\.[A-Za-z0-9]+)?$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}(?:\\.[A-Za-z0-9]+)?$" })),
+		digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+		bytes: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+		contentType: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+		url: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^https?:\\/\\/", "u")).annotate({ expected: "a string matching the RegExp ^https?:\\/\\/" }))
+	})),
+	warnings: Schema.Array(Schema.Struct({
+		code: Schema.String,
+		severity: Schema.Union([
+			Schema.Literal("error"),
+			Schema.Literal("warning"),
+			Schema.Literal("info")
+		]),
+		message: Schema.String,
+		origins: Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		})),
+		clients: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		notes: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		provenance: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		fixtures: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		occurrences: Schema.optionalKey(Schema.Union([Schema.Array(Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		}))), Schema.Null])),
+		compatibility: Schema.optionalKey(Schema.Union([Schema.Struct({
+			assessment: Schema.Union([
+				Schema.Literal("risk"),
+				Schema.Literal("degradation"),
+				Schema.Literal("unverified"),
+				Schema.Literal("not-applicable")
+			]),
+			title: Schema.String
+		}), Schema.Null]))
+	})),
+	incompatibilities: Schema.Array(Schema.Struct({
+		code: Schema.String,
+		severity: Schema.Union([
+			Schema.Literal("error"),
+			Schema.Literal("warning"),
+			Schema.Literal("info")
+		]),
+		message: Schema.String,
+		origins: Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		})),
+		clients: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		notes: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		provenance: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		fixtures: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		occurrences: Schema.optionalKey(Schema.Union([Schema.Array(Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		}))), Schema.Null])),
+		compatibility: Schema.optionalKey(Schema.Union([Schema.Struct({
+			assessment: Schema.Union([
+				Schema.Literal("risk"),
+				Schema.Literal("degradation"),
+				Schema.Literal("unverified"),
+				Schema.Literal("not-applicable")
+			]),
+			title: Schema.String
+		}), Schema.Null]))
+	})),
+	status: Schema.String,
+	publishedAt: Schema.String,
+	publishedBy: Schema.Union([Schema.String, Schema.Null]),
+	createdAt: Schema.String
+});
+const TemplatesGetPublication401 = UnauthorizedError;
+const TemplatesGetPublication403 = ForbiddenError;
+const TemplatesGetPublication404 = ResourceNotFoundError;
+const TemplatesGetPublication422 = ValidationError;
+const TemplatesGetPublication500 = InternalError;
+const TemplatesGetPublication504 = GatewayTimeoutError;
+const TemplatesRenderPublicationPathParams = /* @__PURE__ */ Schema.Struct({
+	id: TemplateId,
+	publicationId: TemplatePublicationId
+});
+const TemplatesRenderPublicationRequestJson = /* @__PURE__ */ Schema.Struct({
+	data: Schema.Record(Schema.String, JsonValue).annotate({ description: "The input to render with, validated against the publication's input schema." }),
+	locale: Schema.optionalKey(RenderLocale),
+	timeZone: Schema.optionalKey(RenderTimeZone)
+});
+const TemplatesRenderPublication200 = TemplatePublicationRender;
+const TemplatesRenderPublication401 = UnauthorizedError;
+const TemplatesRenderPublication403 = ForbiddenError;
+const TemplatesRenderPublication404 = ResourceNotFoundError;
+const TemplatesRenderPublication409 = ConflictError;
+const TemplatesRenderPublication422 = ValidationError;
+const TemplatesRenderPublication500 = InternalError;
+const TemplatesRenderPublication504 = GatewayTimeoutError;
+const TemplatesGetGitRepositoryPathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesGetGitRepository200 = /* @__PURE__ */ Schema.Struct({
+	remote: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^https:\\/\\/", "u")).annotate({ expected: "a string matching the RegExp ^https:\\/\\/" })),
+	defaultBranch: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" }))
+});
+const TemplatesGetGitRepository401 = UnauthorizedError;
+const TemplatesGetGitRepository403 = ForbiddenError;
+const TemplatesGetGitRepository404 = ResourceNotFoundError;
+const TemplatesGetGitRepository409 = ConflictError;
+const TemplatesGetGitRepository422 = ValidationError;
+const TemplatesGetGitRepository500 = InternalError;
+const TemplatesGetGitRepository504 = GatewayTimeoutError;
+const TemplatesIssueGitCredentialPathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesIssueGitCredentialRequestJson = /* @__PURE__ */ Schema.Struct({ scope: Schema.Union([Schema.Literal("read"), Schema.Literal("write")]) });
+const TemplatesIssueGitCredential200 = /* @__PURE__ */ Schema.Struct({
+	remote: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^https:\\/\\/", "u")).annotate({ expected: "a string matching the RegExp ^https:\\/\\/" })),
+	username: Schema.Literal("x-access-token"),
+	password: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+	expiresAt: Schema.String
+});
+const TemplatesIssueGitCredential401 = UnauthorizedError;
+const TemplatesIssueGitCredential403 = ForbiddenError;
+const TemplatesIssueGitCredential404 = ResourceNotFoundError;
+const TemplatesIssueGitCredential409 = ConflictError;
+const TemplatesIssueGitCredential422 = ValidationError;
+const TemplatesIssueGitCredential500 = InternalError;
+const TemplatesIssueGitCredential504 = GatewayTimeoutError;
+const TemplatesOpenWorkspacePathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesOpenWorkspace200 = /* @__PURE__ */ Schema.Struct({
+	workspace: Schema.Struct({
+		projectId: TemplateProjectId,
+		organizationId: Schema.Union([OrganizationId, Schema.Null]),
+		ownerEpoch: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+		repositoryName: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$", "u")).annotate({ expected: "a string matching the RegExp ^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$" })),
+		defaultBranch: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" })),
+		baseCommit: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+		remoteHead: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+		pendingRemoteHead: Schema.Union([Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })), Schema.Null]),
+		revision: Schema.String,
+		overlay: Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Null])),
+		assetChanges: Schema.Array(Schema.Struct({
+			path: Schema.String,
+			status: Schema.Union([
+				Schema.Literal("added"),
+				Schema.Literal("modified"),
+				Schema.Literal("deleted")
+			])
+		})),
+		conflicts: Schema.Array(Schema.Struct({
+			path: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$" })),
+			base: Schema.Union([Schema.String, Schema.Null]),
+			draft: Schema.Union([Schema.String, Schema.Null]),
+			main: Schema.Union([Schema.String, Schema.Null])
+		})),
+		provenance: Schema.Struct({ references: Schema.Array(Schema.Struct({
+			kind: Schema.String,
+			digest: Schema.String,
+			locator: Schema.optionalKey(Schema.String)
+		})) }),
+		mounts: Schema.Array(Schema.Union([
+			Schema.Struct({
+				kind: Schema.Literal("project"),
+				root: Schema.Literal("/project"),
+				access: Schema.Literal("read-write")
+			}),
+			Schema.Struct({
+				root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+				digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+				fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				kind: Schema.Literal("started-from"),
+				access: Schema.Literal("read-only"),
+				templateId: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+				slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9]+(?:-[a-z0-9]+)*$" })),
+				name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+			}),
+			Schema.Struct({
+				root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+				digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+				fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				kind: Schema.Literal("resource"),
+				access: Schema.Literal("read-only"),
+				resourceId: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[A-Za-z0-9._-]{1,128}$", "u")).annotate({ expected: "a string matching the RegExp ^[A-Za-z0-9._-]{1,128}$" })),
+				name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+			}),
+			Schema.Struct({
+				root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+				digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+				fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				kind: Schema.Literal("library-template"),
+				access: Schema.Literal("read-only"),
+				templateId: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+				slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9]+(?:-[a-z0-9]+)*$" })),
+				name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+			})
+		])),
+		libraryManifestDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+		createdAt: Schema.String,
+		updatedAt: Schema.String,
+		createdBy: Schema.Struct({
+			userId: UserId,
+			via: Schema.Union([
+				Schema.Literal("api"),
+				Schema.Literal("mcp"),
+				Schema.Literal("agent")
+			])
+		}),
+		updatedBy: Schema.Struct({
+			userId: UserId,
+			via: Schema.Union([
+				Schema.Literal("api"),
+				Schema.Literal("mcp"),
+				Schema.Literal("agent")
+			])
+		})
+	}),
+	files: Schema.Record(Schema.String, Schema.String)
+});
+const TemplatesOpenWorkspace401 = UnauthorizedError;
+const TemplatesOpenWorkspace403 = ForbiddenError;
+const TemplatesOpenWorkspace404 = ResourceNotFoundError;
+const TemplatesOpenWorkspace409 = ConflictError;
+const TemplatesOpenWorkspace422 = ValidationError;
+const TemplatesOpenWorkspace500 = InternalError;
+const TemplatesOpenWorkspace504 = GatewayTimeoutError;
+const TemplatesPatchWorkspacePathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesPatchWorkspaceRequestJson = /* @__PURE__ */ Schema.Struct({
+	expectedRevision: Schema.String,
+	patches: Schema.Array(Schema.Struct({
+		path: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$" })),
+		content: Schema.Union([Schema.String.check(Schema.isMaxCodePoints(1048576).annotate({ expected: "a string with at most 1048576 code points" })).check(Schema.isMaxLength(1048576).annotate({ expected: "a value with a length of at most 1048576" })), Schema.Null])
+	})).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxLength(512).annotate({ expected: "a value with a length of at most 512" })),
+	idempotencyKey: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" }))
+});
+const TemplatesPatchWorkspace200 = /* @__PURE__ */ Schema.Struct({
+	workspace: Schema.Struct({
+		projectId: TemplateProjectId,
+		organizationId: Schema.Union([OrganizationId, Schema.Null]),
+		ownerEpoch: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+		repositoryName: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$", "u")).annotate({ expected: "a string matching the RegExp ^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$" })),
+		defaultBranch: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" })),
+		baseCommit: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+		remoteHead: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+		pendingRemoteHead: Schema.Union([Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })), Schema.Null]),
+		revision: Schema.String,
+		overlay: Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Null])),
+		assetChanges: Schema.Array(Schema.Struct({
+			path: Schema.String,
+			status: Schema.Union([
+				Schema.Literal("added"),
+				Schema.Literal("modified"),
+				Schema.Literal("deleted")
+			])
+		})),
+		conflicts: Schema.Array(Schema.Struct({
+			path: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$" })),
+			base: Schema.Union([Schema.String, Schema.Null]),
+			draft: Schema.Union([Schema.String, Schema.Null]),
+			main: Schema.Union([Schema.String, Schema.Null])
+		})),
+		provenance: Schema.Struct({ references: Schema.Array(Schema.Struct({
+			kind: Schema.String,
+			digest: Schema.String,
+			locator: Schema.optionalKey(Schema.String)
+		})) }),
+		mounts: Schema.Array(Schema.Union([
+			Schema.Struct({
+				kind: Schema.Literal("project"),
+				root: Schema.Literal("/project"),
+				access: Schema.Literal("read-write")
+			}),
+			Schema.Struct({
+				root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+				digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+				fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				kind: Schema.Literal("started-from"),
+				access: Schema.Literal("read-only"),
+				templateId: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+				slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9]+(?:-[a-z0-9]+)*$" })),
+				name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+			}),
+			Schema.Struct({
+				root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+				digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+				fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				kind: Schema.Literal("resource"),
+				access: Schema.Literal("read-only"),
+				resourceId: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[A-Za-z0-9._-]{1,128}$", "u")).annotate({ expected: "a string matching the RegExp ^[A-Za-z0-9._-]{1,128}$" })),
+				name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+			}),
+			Schema.Struct({
+				root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+				digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+				fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				kind: Schema.Literal("library-template"),
+				access: Schema.Literal("read-only"),
+				templateId: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+				slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9]+(?:-[a-z0-9]+)*$" })),
+				name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+			})
+		])),
+		libraryManifestDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+		createdAt: Schema.String,
+		updatedAt: Schema.String,
+		createdBy: Schema.Struct({
+			userId: UserId,
+			via: Schema.Union([
+				Schema.Literal("api"),
+				Schema.Literal("mcp"),
+				Schema.Literal("agent")
+			])
+		}),
+		updatedBy: Schema.Struct({
+			userId: UserId,
+			via: Schema.Union([
+				Schema.Literal("api"),
+				Schema.Literal("mcp"),
+				Schema.Literal("agent")
+			])
+		})
+	}),
+	files: Schema.Record(Schema.String, Schema.String)
+});
+const TemplatesPatchWorkspace401 = UnauthorizedError;
+const TemplatesPatchWorkspace403 = ForbiddenError;
+const TemplatesPatchWorkspace404 = ResourceNotFoundError;
+const TemplatesPatchWorkspace409 = ConflictError;
+const TemplatesPatchWorkspace422 = ValidationError;
+const TemplatesPatchWorkspace500 = InternalError;
+const TemplatesPatchWorkspace504 = GatewayTimeoutError;
+const TemplatesPutWorkspaceAssetPathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesPutWorkspaceAssetRequestJson = /* @__PURE__ */ Schema.Struct({
+	expectedRevision: Schema.String,
+	path: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$" })),
+	contentBase64: Schema.String,
+	replace: Schema.Boolean,
+	idempotencyKey: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" }))
+});
+const TemplatesPutWorkspaceAsset200 = /* @__PURE__ */ Schema.Struct({
+	workspace: Schema.Struct({
+		projectId: TemplateProjectId,
+		organizationId: Schema.Union([OrganizationId, Schema.Null]),
+		ownerEpoch: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+		repositoryName: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$", "u")).annotate({ expected: "a string matching the RegExp ^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$" })),
+		defaultBranch: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" })),
+		baseCommit: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+		remoteHead: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+		pendingRemoteHead: Schema.Union([Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })), Schema.Null]),
+		revision: Schema.String,
+		overlay: Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Null])),
+		assetChanges: Schema.Array(Schema.Struct({
+			path: Schema.String,
+			status: Schema.Union([
+				Schema.Literal("added"),
+				Schema.Literal("modified"),
+				Schema.Literal("deleted")
+			])
+		})),
+		conflicts: Schema.Array(Schema.Struct({
+			path: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$" })),
+			base: Schema.Union([Schema.String, Schema.Null]),
+			draft: Schema.Union([Schema.String, Schema.Null]),
+			main: Schema.Union([Schema.String, Schema.Null])
+		})),
+		provenance: Schema.Struct({ references: Schema.Array(Schema.Struct({
+			kind: Schema.String,
+			digest: Schema.String,
+			locator: Schema.optionalKey(Schema.String)
+		})) }),
+		mounts: Schema.Array(Schema.Union([
+			Schema.Struct({
+				kind: Schema.Literal("project"),
+				root: Schema.Literal("/project"),
+				access: Schema.Literal("read-write")
+			}),
+			Schema.Struct({
+				root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+				digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+				fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				kind: Schema.Literal("started-from"),
+				access: Schema.Literal("read-only"),
+				templateId: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+				slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9]+(?:-[a-z0-9]+)*$" })),
+				name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+			}),
+			Schema.Struct({
+				root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+				digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+				fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				kind: Schema.Literal("resource"),
+				access: Schema.Literal("read-only"),
+				resourceId: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[A-Za-z0-9._-]{1,128}$", "u")).annotate({ expected: "a string matching the RegExp ^[A-Za-z0-9._-]{1,128}$" })),
+				name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+			}),
+			Schema.Struct({
+				root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+				digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+				fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				kind: Schema.Literal("library-template"),
+				access: Schema.Literal("read-only"),
+				templateId: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+				slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9]+(?:-[a-z0-9]+)*$" })),
+				name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+			})
+		])),
+		libraryManifestDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+		createdAt: Schema.String,
+		updatedAt: Schema.String,
+		createdBy: Schema.Struct({
+			userId: UserId,
+			via: Schema.Union([
+				Schema.Literal("api"),
+				Schema.Literal("mcp"),
+				Schema.Literal("agent")
+			])
+		}),
+		updatedBy: Schema.Struct({
+			userId: UserId,
+			via: Schema.Union([
+				Schema.Literal("api"),
+				Schema.Literal("mcp"),
+				Schema.Literal("agent")
+			])
+		})
+	}),
+	files: Schema.Record(Schema.String, Schema.String)
+});
+const TemplatesPutWorkspaceAsset401 = UnauthorizedError;
+const TemplatesPutWorkspaceAsset403 = ForbiddenError;
+const TemplatesPutWorkspaceAsset404 = ResourceNotFoundError;
+const TemplatesPutWorkspaceAsset409 = ConflictError;
+const TemplatesPutWorkspaceAsset422 = ValidationError;
+const TemplatesPutWorkspaceAsset500 = InternalError;
+const TemplatesPutWorkspaceAsset504 = GatewayTimeoutError;
+const TemplatesCheckWorkspacePathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesCheckWorkspaceRequestJson = /* @__PURE__ */ Schema.Struct({ expectedRevision: Schema.String });
+const TemplatesCheckWorkspace200 = /* @__PURE__ */ Schema.Struct({
+	projectId: TemplateProjectId,
+	revision: Schema.String,
+	entryPath: Schema.String.check(Schema.isMaxCodePoints(1024).annotate({ expected: "a string with at most 1024 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$", "u")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$" })).check(Schema.isMaxLength(1024).annotate({ expected: "a value with a length of at most 1024" })),
+	declaration: Schema.Union([Schema.Struct({
+		codeDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+		templateId: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+		input: Schema.Struct({
+			schema: Schema.Record(Schema.String, JsonValue),
+			schemaDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+			contractDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" }))
+		}),
+		fixtures: Schema.Array(Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })))
+	}), Schema.Null]),
+	diagnostics: Schema.Array(Schema.Struct({
+		code: Schema.String,
+		severity: Schema.Union([
+			Schema.Literal("error"),
+			Schema.Literal("warning"),
+			Schema.Literal("info")
+		]),
+		message: Schema.String,
+		origins: Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		})),
+		clients: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		notes: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		provenance: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		fixtures: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		occurrences: Schema.optionalKey(Schema.Union([Schema.Array(Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		}))), Schema.Null])),
+		compatibility: Schema.optionalKey(Schema.Union([Schema.Struct({
+			assessment: Schema.Union([
+				Schema.Literal("risk"),
+				Schema.Literal("degradation"),
+				Schema.Literal("unverified"),
+				Schema.Literal("not-applicable")
+			]),
+			title: Schema.String
+		}), Schema.Null]))
+	})),
+	incompatibilities: Schema.Array(Schema.Struct({
+		code: Schema.String,
+		severity: Schema.Union([
+			Schema.Literal("error"),
+			Schema.Literal("warning"),
+			Schema.Literal("info")
+		]),
+		message: Schema.String,
+		origins: Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		})),
+		clients: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		notes: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		provenance: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		fixtures: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		occurrences: Schema.optionalKey(Schema.Union([Schema.Array(Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		}))), Schema.Null])),
+		compatibility: Schema.optionalKey(Schema.Union([Schema.Struct({
+			assessment: Schema.Union([
+				Schema.Literal("risk"),
+				Schema.Literal("degradation"),
+				Schema.Literal("unverified"),
+				Schema.Literal("not-applicable")
+			]),
+			title: Schema.String
+		}), Schema.Null]))
+	}))
+});
+const TemplatesCheckWorkspace401 = UnauthorizedError;
+const TemplatesCheckWorkspace403 = ForbiddenError;
+const TemplatesCheckWorkspace404 = ResourceNotFoundError;
+const TemplatesCheckWorkspace409 = ConflictError;
+const TemplatesCheckWorkspace422 = ValidationError;
+const TemplatesCheckWorkspace500 = InternalError;
+const TemplatesCheckWorkspace504 = GatewayTimeoutError;
+const TemplatesResolveWorkspaceConflictPathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesResolveWorkspaceConflictRequestJson = /* @__PURE__ */ Schema.Struct({
+	expectedRevision: Schema.String,
+	path: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$" })),
+	resolution: Schema.Union([
+		Schema.Literal("draft"),
+		Schema.Literal("main"),
+		Schema.Struct({ content: Schema.Union([Schema.String, Schema.Null]) })
+	]),
+	idempotencyKey: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" }))
+});
+const TemplatesResolveWorkspaceConflict200 = /* @__PURE__ */ Schema.Struct({
+	workspace: Schema.Struct({
+		projectId: TemplateProjectId,
+		organizationId: Schema.Union([OrganizationId, Schema.Null]),
+		ownerEpoch: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+		repositoryName: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$", "u")).annotate({ expected: "a string matching the RegExp ^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$" })),
+		defaultBranch: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" })),
+		baseCommit: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+		remoteHead: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+		pendingRemoteHead: Schema.Union([Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })), Schema.Null]),
+		revision: Schema.String,
+		overlay: Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Null])),
+		assetChanges: Schema.Array(Schema.Struct({
+			path: Schema.String,
+			status: Schema.Union([
+				Schema.Literal("added"),
+				Schema.Literal("modified"),
+				Schema.Literal("deleted")
+			])
+		})),
+		conflicts: Schema.Array(Schema.Struct({
+			path: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$" })),
+			base: Schema.Union([Schema.String, Schema.Null]),
+			draft: Schema.Union([Schema.String, Schema.Null]),
+			main: Schema.Union([Schema.String, Schema.Null])
+		})),
+		provenance: Schema.Struct({ references: Schema.Array(Schema.Struct({
+			kind: Schema.String,
+			digest: Schema.String,
+			locator: Schema.optionalKey(Schema.String)
+		})) }),
+		mounts: Schema.Array(Schema.Union([
+			Schema.Struct({
+				kind: Schema.Literal("project"),
+				root: Schema.Literal("/project"),
+				access: Schema.Literal("read-write")
+			}),
+			Schema.Struct({
+				root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+				digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+				fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				kind: Schema.Literal("started-from"),
+				access: Schema.Literal("read-only"),
+				templateId: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+				slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9]+(?:-[a-z0-9]+)*$" })),
+				name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+			}),
+			Schema.Struct({
+				root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+				digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+				fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				kind: Schema.Literal("resource"),
+				access: Schema.Literal("read-only"),
+				resourceId: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[A-Za-z0-9._-]{1,128}$", "u")).annotate({ expected: "a string matching the RegExp ^[A-Za-z0-9._-]{1,128}$" })),
+				name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+			}),
+			Schema.Struct({
+				root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+				digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+				fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				kind: Schema.Literal("library-template"),
+				access: Schema.Literal("read-only"),
+				templateId: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+				slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9]+(?:-[a-z0-9]+)*$" })),
+				name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+			})
+		])),
+		libraryManifestDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+		createdAt: Schema.String,
+		updatedAt: Schema.String,
+		createdBy: Schema.Struct({
+			userId: UserId,
+			via: Schema.Union([
+				Schema.Literal("api"),
+				Schema.Literal("mcp"),
+				Schema.Literal("agent")
+			])
+		}),
+		updatedBy: Schema.Struct({
+			userId: UserId,
+			via: Schema.Union([
+				Schema.Literal("api"),
+				Schema.Literal("mcp"),
+				Schema.Literal("agent")
+			])
+		})
+	}),
+	files: Schema.Record(Schema.String, Schema.String)
+});
+const TemplatesResolveWorkspaceConflict401 = UnauthorizedError;
+const TemplatesResolveWorkspaceConflict403 = ForbiddenError;
+const TemplatesResolveWorkspaceConflict404 = ResourceNotFoundError;
+const TemplatesResolveWorkspaceConflict409 = ConflictError;
+const TemplatesResolveWorkspaceConflict422 = ValidationError;
+const TemplatesResolveWorkspaceConflict500 = InternalError;
+const TemplatesResolveWorkspaceConflict504 = GatewayTimeoutError;
+const TemplatesDiffWorkspacePathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesDiffWorkspaceRequestJson = /* @__PURE__ */ Schema.Struct({ expectedRevision: Schema.String });
+const TemplatesDiffWorkspace200 = /* @__PURE__ */ Schema.Struct({
+	projectId: TemplateProjectId,
+	baseCommit: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+	revision: Schema.String,
+	changes: Schema.Array(Schema.Struct({
+		path: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$" })),
+		before: Schema.Union([Schema.String.check(Schema.isMaxCodePoints(1048576).annotate({ expected: "a string with at most 1048576 code points" })).check(Schema.isMaxLength(1048576).annotate({ expected: "a value with a length of at most 1048576" })), Schema.Null]),
+		after: Schema.Union([Schema.String.check(Schema.isMaxCodePoints(1048576).annotate({ expected: "a string with at most 1048576 code points" })).check(Schema.isMaxLength(1048576).annotate({ expected: "a value with a length of at most 1048576" })), Schema.Null]),
+		status: Schema.Union([
+			Schema.Literal("added"),
+			Schema.Literal("modified"),
+			Schema.Literal("deleted")
+		])
+	})),
+	assetChanges: Schema.Array(Schema.Struct({
+		path: Schema.String,
+		status: Schema.Union([
+			Schema.Literal("added"),
+			Schema.Literal("modified"),
+			Schema.Literal("deleted")
+		])
+	}))
+});
+const TemplatesDiffWorkspace401 = UnauthorizedError;
+const TemplatesDiffWorkspace403 = ForbiddenError;
+const TemplatesDiffWorkspace404 = ResourceNotFoundError;
+const TemplatesDiffWorkspace409 = ConflictError;
+const TemplatesDiffWorkspace422 = ValidationError;
+const TemplatesDiffWorkspace500 = InternalError;
+const TemplatesDiffWorkspace504 = GatewayTimeoutError;
+const TemplatesRenderWorkspaceFixturePathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesRenderWorkspaceFixtureRequestJson = /* @__PURE__ */ Schema.Struct({
+	expectedRevision: Schema.String,
+	fixture: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" }))
+});
+const TemplatesRenderWorkspaceFixture200 = /* @__PURE__ */ Schema.Struct({
+	projectId: TemplateProjectId,
+	revision: Schema.String,
+	entryPath: Schema.String.check(Schema.isMaxCodePoints(1024).annotate({ expected: "a string with at most 1024 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$", "u")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$" })).check(Schema.isMaxLength(1024).annotate({ expected: "a value with a length of at most 1024" })),
+	declaration: Schema.Union([Schema.Struct({
+		codeDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+		templateId: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+		input: Schema.Struct({
+			schema: Schema.Record(Schema.String, JsonValue),
+			schemaDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+			contractDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" }))
+		}),
+		fixtures: Schema.Array(Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })))
+	}), Schema.Null]),
+	diagnostics: Schema.Array(Schema.Struct({
+		code: Schema.String,
+		severity: Schema.Union([
+			Schema.Literal("error"),
+			Schema.Literal("warning"),
+			Schema.Literal("info")
+		]),
+		message: Schema.String,
+		origins: Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		})),
+		clients: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		notes: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		provenance: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		fixtures: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		occurrences: Schema.optionalKey(Schema.Union([Schema.Array(Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		}))), Schema.Null])),
+		compatibility: Schema.optionalKey(Schema.Union([Schema.Struct({
+			assessment: Schema.Union([
+				Schema.Literal("risk"),
+				Schema.Literal("degradation"),
+				Schema.Literal("unverified"),
+				Schema.Literal("not-applicable")
+			]),
+			title: Schema.String
+		}), Schema.Null]))
+	})),
+	incompatibilities: Schema.Array(Schema.Struct({
+		code: Schema.String,
+		severity: Schema.Union([
+			Schema.Literal("error"),
+			Schema.Literal("warning"),
+			Schema.Literal("info")
+		]),
+		message: Schema.String,
+		origins: Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		})),
+		clients: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		notes: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		provenance: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		fixtures: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		occurrences: Schema.optionalKey(Schema.Union([Schema.Array(Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		}))), Schema.Null])),
+		compatibility: Schema.optionalKey(Schema.Union([Schema.Struct({
+			assessment: Schema.Union([
+				Schema.Literal("risk"),
+				Schema.Literal("degradation"),
+				Schema.Literal("unverified"),
+				Schema.Literal("not-applicable")
+			]),
+			title: Schema.String
+		}), Schema.Null]))
+	})),
+	fixture: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+	rendered: Schema.Union([Schema.Struct({
+		subject: Schema.String,
+		preheader: Schema.optionalKey(Schema.String),
+		html: Schema.String.check(Schema.isMaxCodePoints(2097152).annotate({ expected: "a string with at most 2097152 code points" })).check(Schema.isMaxLength(2097152).annotate({ expected: "a value with a length of at most 2097152" })),
+		text: Schema.String.check(Schema.isMaxCodePoints(2097152).annotate({ expected: "a string with at most 2097152 code points" })).check(Schema.isMaxLength(2097152).annotate({ expected: "a value with a length of at most 2097152" })),
+		selections: Schema.Array(Schema.Struct({
+			instancePath: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+			tag: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })),
+			origins: Schema.Array(Schema.Struct({
+				fileName: Schema.String,
+				lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+				columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+			})),
+			authored: Schema.Boolean,
+			occurrence: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			occurrences: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			parentPath: Schema.optionalKey(Schema.String),
+			start: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+			end: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" }))
+		}))
+	}), Schema.Null])
+});
+const TemplatesRenderWorkspaceFixture401 = UnauthorizedError;
+const TemplatesRenderWorkspaceFixture403 = ForbiddenError;
+const TemplatesRenderWorkspaceFixture404 = ResourceNotFoundError;
+const TemplatesRenderWorkspaceFixture409 = ConflictError;
+const TemplatesRenderWorkspaceFixture422 = ValidationError;
+const TemplatesRenderWorkspaceFixture500 = InternalError;
+const TemplatesRenderWorkspaceFixture504 = GatewayTimeoutError;
+const TemplatesWorkspaceHistoryPathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesWorkspaceHistoryQuery = /* @__PURE__ */ Schema.Struct({ limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])) });
+const TemplatesWorkspaceHistory200 = /* @__PURE__ */ Schema.Struct({
+	projectId: TemplateProjectId,
+	head: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+	commits: Schema.Array(Schema.Struct({
+		commit: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+		tree: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+		parentCommit: Schema.Union([Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })), Schema.Null]),
+		message: Schema.String,
+		committedAt: Schema.String
+	})),
+	publication: Schema.Union([Schema.Struct({
+		id: TemplatePublicationId,
+		commit: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" }))
+	}), Schema.Null])
+});
+const TemplatesWorkspaceHistory401 = UnauthorizedError;
+const TemplatesWorkspaceHistory403 = ForbiddenError;
+const TemplatesWorkspaceHistory404 = ResourceNotFoundError;
+const TemplatesWorkspaceHistory409 = ConflictError;
+const TemplatesWorkspaceHistory422 = ValidationError;
+const TemplatesWorkspaceHistory500 = InternalError;
+const TemplatesWorkspaceHistory504 = GatewayTimeoutError;
+const TemplatesAttachWorkspaceResourcePathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesAttachWorkspaceResourceRequestJson = /* @__PURE__ */ Schema.Struct({
+	expectedRevision: Schema.String,
+	resource: Schema.Struct({
+		resourceId: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[A-Za-z0-9._-]{1,128}$", "u")).annotate({ expected: "a string matching the RegExp ^[A-Za-z0-9._-]{1,128}$" })),
+		name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" })),
+		files: Schema.Array(Schema.Struct({
+			path: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$" })),
+			mediaType: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" })),
+			contentBase64: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$", "u")).annotate({ expected: "a string matching the RegExp ^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$" }))
+		})).check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxLength(32).annotate({ expected: "a value with a length of at most 32" }))
+	}),
+	idempotencyKey: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" }))
+});
+const TemplatesAttachWorkspaceResource200 = /* @__PURE__ */ Schema.Struct({
+	projectId: TemplateProjectId,
+	organizationId: Schema.Union([OrganizationId, Schema.Null]),
+	ownerEpoch: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	repositoryName: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$", "u")).annotate({ expected: "a string matching the RegExp ^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$" })),
+	defaultBranch: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" })),
+	baseCommit: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+	remoteHead: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+	pendingRemoteHead: Schema.Union([Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })), Schema.Null]),
+	revision: Schema.String,
+	overlay: Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Null])),
+	assetChanges: Schema.Array(Schema.Struct({
+		path: Schema.String,
+		status: Schema.Union([
+			Schema.Literal("added"),
+			Schema.Literal("modified"),
+			Schema.Literal("deleted")
+		])
+	})),
+	conflicts: Schema.Array(Schema.Struct({
+		path: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$" })),
+		base: Schema.Union([Schema.String, Schema.Null]),
+		draft: Schema.Union([Schema.String, Schema.Null]),
+		main: Schema.Union([Schema.String, Schema.Null])
+	})),
+	provenance: Schema.Struct({ references: Schema.Array(Schema.Struct({
+		kind: Schema.String,
+		digest: Schema.String,
+		locator: Schema.optionalKey(Schema.String)
+	})) }),
+	mounts: Schema.Array(Schema.Union([
+		Schema.Struct({
+			kind: Schema.Literal("project"),
+			root: Schema.Literal("/project"),
+			access: Schema.Literal("read-write")
+		}),
+		Schema.Struct({
+			root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+			digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+			fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			kind: Schema.Literal("started-from"),
+			access: Schema.Literal("read-only"),
+			templateId: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+			slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9]+(?:-[a-z0-9]+)*$" })),
+			name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+		}),
+		Schema.Struct({
+			root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+			digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+			fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			kind: Schema.Literal("resource"),
+			access: Schema.Literal("read-only"),
+			resourceId: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[A-Za-z0-9._-]{1,128}$", "u")).annotate({ expected: "a string matching the RegExp ^[A-Za-z0-9._-]{1,128}$" })),
+			name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+		}),
+		Schema.Struct({
+			root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+			digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+			fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			kind: Schema.Literal("library-template"),
+			access: Schema.Literal("read-only"),
+			templateId: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+			slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9]+(?:-[a-z0-9]+)*$" })),
+			name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+		})
+	])),
+	libraryManifestDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+	createdAt: Schema.String,
+	updatedAt: Schema.String,
+	createdBy: Schema.Struct({
+		userId: UserId,
+		via: Schema.Union([
+			Schema.Literal("api"),
+			Schema.Literal("mcp"),
+			Schema.Literal("agent")
+		])
+	}),
+	updatedBy: Schema.Struct({
+		userId: UserId,
+		via: Schema.Union([
+			Schema.Literal("api"),
+			Schema.Literal("mcp"),
+			Schema.Literal("agent")
+		])
+	})
+});
+const TemplatesAttachWorkspaceResource401 = UnauthorizedError;
+const TemplatesAttachWorkspaceResource403 = ForbiddenError;
+const TemplatesAttachWorkspaceResource404 = ResourceNotFoundError;
+const TemplatesAttachWorkspaceResource409 = ConflictError;
+const TemplatesAttachWorkspaceResource422 = ValidationError;
+const TemplatesAttachWorkspaceResource500 = InternalError;
+const TemplatesAttachWorkspaceResource504 = GatewayTimeoutError;
+const TemplatesRemoveWorkspaceResourcePathParams = /* @__PURE__ */ Schema.Struct({
+	id: TemplateId,
+	resourceId: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[A-Za-z0-9._-]{1,128}$", "u")).annotate({ expected: "a string matching the RegExp ^[A-Za-z0-9._-]{1,128}$" }))
+});
+const TemplatesRemoveWorkspaceResourceRequestJson = /* @__PURE__ */ Schema.Struct({
+	expectedRevision: Schema.String,
+	idempotencyKey: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" }))
+});
+const TemplatesRemoveWorkspaceResource200 = /* @__PURE__ */ Schema.Struct({
+	projectId: TemplateProjectId,
+	organizationId: Schema.Union([OrganizationId, Schema.Null]),
+	ownerEpoch: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+	repositoryName: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$", "u")).annotate({ expected: "a string matching the RegExp ^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$" })),
+	defaultBranch: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" })),
+	baseCommit: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+	remoteHead: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+	pendingRemoteHead: Schema.Union([Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })), Schema.Null]),
+	revision: Schema.String,
+	overlay: Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Null])),
+	assetChanges: Schema.Array(Schema.Struct({
+		path: Schema.String,
+		status: Schema.Union([
+			Schema.Literal("added"),
+			Schema.Literal("modified"),
+			Schema.Literal("deleted")
+		])
+	})),
+	conflicts: Schema.Array(Schema.Struct({
+		path: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$" })),
+		base: Schema.Union([Schema.String, Schema.Null]),
+		draft: Schema.Union([Schema.String, Schema.Null]),
+		main: Schema.Union([Schema.String, Schema.Null])
+	})),
+	provenance: Schema.Struct({ references: Schema.Array(Schema.Struct({
+		kind: Schema.String,
+		digest: Schema.String,
+		locator: Schema.optionalKey(Schema.String)
+	})) }),
+	mounts: Schema.Array(Schema.Union([
+		Schema.Struct({
+			kind: Schema.Literal("project"),
+			root: Schema.Literal("/project"),
+			access: Schema.Literal("read-write")
+		}),
+		Schema.Struct({
+			root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+			digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+			fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			kind: Schema.Literal("started-from"),
+			access: Schema.Literal("read-only"),
+			templateId: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+			slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9]+(?:-[a-z0-9]+)*$" })),
+			name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+		}),
+		Schema.Struct({
+			root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+			digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+			fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			kind: Schema.Literal("resource"),
+			access: Schema.Literal("read-only"),
+			resourceId: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[A-Za-z0-9._-]{1,128}$", "u")).annotate({ expected: "a string matching the RegExp ^[A-Za-z0-9._-]{1,128}$" })),
+			name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+		}),
+		Schema.Struct({
+			root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+			digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+			fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			kind: Schema.Literal("library-template"),
+			access: Schema.Literal("read-only"),
+			templateId: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+			slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9]+(?:-[a-z0-9]+)*$" })),
+			name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+		})
+	])),
+	libraryManifestDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+	createdAt: Schema.String,
+	updatedAt: Schema.String,
+	createdBy: Schema.Struct({
+		userId: UserId,
+		via: Schema.Union([
+			Schema.Literal("api"),
+			Schema.Literal("mcp"),
+			Schema.Literal("agent")
+		])
+	}),
+	updatedBy: Schema.Struct({
+		userId: UserId,
+		via: Schema.Union([
+			Schema.Literal("api"),
+			Schema.Literal("mcp"),
+			Schema.Literal("agent")
+		])
+	})
+});
+const TemplatesRemoveWorkspaceResource401 = UnauthorizedError;
+const TemplatesRemoveWorkspaceResource403 = ForbiddenError;
+const TemplatesRemoveWorkspaceResource404 = ResourceNotFoundError;
+const TemplatesRemoveWorkspaceResource409 = ConflictError;
+const TemplatesRemoveWorkspaceResource422 = ValidationError;
+const TemplatesRemoveWorkspaceResource500 = InternalError;
+const TemplatesRemoveWorkspaceResource504 = GatewayTimeoutError;
+const TemplatesRestoreWorkspacePathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesRestoreWorkspaceRequestJson = /* @__PURE__ */ Schema.Struct({
+	expectedRevision: Schema.String,
+	commit: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+	idempotencyKey: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" }))
+});
+const TemplatesRestoreWorkspace200 = /* @__PURE__ */ Schema.Struct({
+	view: Schema.Struct({
+		workspace: Schema.Struct({
+			projectId: TemplateProjectId,
+			organizationId: Schema.Union([OrganizationId, Schema.Null]),
+			ownerEpoch: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })),
+			repositoryName: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$", "u")).annotate({ expected: "a string matching the RegExp ^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$" })),
+			defaultBranch: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" })),
+			baseCommit: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+			remoteHead: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+			pendingRemoteHead: Schema.Union([Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })), Schema.Null]),
+			revision: Schema.String,
+			overlay: Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Null])),
+			assetChanges: Schema.Array(Schema.Struct({
+				path: Schema.String,
+				status: Schema.Union([
+					Schema.Literal("added"),
+					Schema.Literal("modified"),
+					Schema.Literal("deleted")
+				])
+			})),
+			conflicts: Schema.Array(Schema.Struct({
+				path: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$" })),
+				base: Schema.Union([Schema.String, Schema.Null]),
+				draft: Schema.Union([Schema.String, Schema.Null]),
+				main: Schema.Union([Schema.String, Schema.Null])
+			})),
+			provenance: Schema.Struct({ references: Schema.Array(Schema.Struct({
+				kind: Schema.String,
+				digest: Schema.String,
+				locator: Schema.optionalKey(Schema.String)
+			})) }),
+			mounts: Schema.Array(Schema.Union([
+				Schema.Struct({
+					kind: Schema.Literal("project"),
+					root: Schema.Literal("/project"),
+					access: Schema.Literal("read-write")
+				}),
+				Schema.Struct({
+					root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+					digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+					fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+					byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+					kind: Schema.Literal("started-from"),
+					access: Schema.Literal("read-only"),
+					templateId: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+					slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9]+(?:-[a-z0-9]+)*$" })),
+					name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+				}),
+				Schema.Struct({
+					root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+					digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+					fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+					byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+					kind: Schema.Literal("resource"),
+					access: Schema.Literal("read-only"),
+					resourceId: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[A-Za-z0-9._-]{1,128}$", "u")).annotate({ expected: "a string matching the RegExp ^[A-Za-z0-9._-]{1,128}$" })),
+					name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+				}),
+				Schema.Struct({
+					root: Schema.String.check(Schema.isMaxCodePoints(2048).annotate({ expected: "a string with at most 2048 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^\\/(?:project|references\\/started-from\\/[a-f0-9]{64}|resources\\/[A-Za-z0-9._-]+\\/[a-f0-9]{64}|library\\/templates\\/[a-z0-9]+(?:-[a-z0-9]+)*\\/[a-f0-9]{64})(?:\\/(?!\\.{1,2}(?:\\/|$)|\\.git(?:\\/|$))[^\\\\/]+)*$" })).check(Schema.isMaxLength(2048).annotate({ expected: "a value with a length of at most 2048" })),
+					digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+					fileCount: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+					byteSize: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+					kind: Schema.Literal("library-template"),
+					access: Schema.Literal("read-only"),
+					templateId: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(128).annotate({ expected: "a string with at most 128 code points" })).check(Schema.isMaxLength(128).annotate({ expected: "a value with a length of at most 128" })),
+					slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^[a-z0-9]+(?:-[a-z0-9]+)*$" })),
+					name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(256).annotate({ expected: "a string with at most 256 code points" })).check(Schema.isMaxLength(256).annotate({ expected: "a value with a length of at most 256" }))
+				})
+			])),
+			libraryManifestDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+			createdAt: Schema.String,
+			updatedAt: Schema.String,
+			createdBy: Schema.Struct({
+				userId: UserId,
+				via: Schema.Union([
+					Schema.Literal("api"),
+					Schema.Literal("mcp"),
+					Schema.Literal("agent")
+				])
+			}),
+			updatedBy: Schema.Struct({
+				userId: UserId,
+				via: Schema.Union([
+					Schema.Literal("api"),
+					Schema.Literal("mcp"),
+					Schema.Literal("agent")
+				])
+			})
+		}),
+		files: Schema.Record(Schema.String, Schema.String)
+	}),
+	source: Schema.Struct({
+		digest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+		content: Schema.String.check(Schema.isMaxCodePoints(2097152).annotate({ expected: "a string with at most 2097152 code points" })).check(Schema.isMaxLength(2097152).annotate({ expected: "a value with a length of at most 2097152" }))
+	})
+});
+const TemplatesRestoreWorkspace401 = UnauthorizedError;
+const TemplatesRestoreWorkspace403 = ForbiddenError;
+const TemplatesRestoreWorkspace404 = ResourceNotFoundError;
+const TemplatesRestoreWorkspace409 = ConflictError;
+const TemplatesRestoreWorkspace422 = ValidationError;
+const TemplatesRestoreWorkspace500 = InternalError;
+const TemplatesRestoreWorkspace504 = GatewayTimeoutError;
+const TemplatesSaveWorkspacePathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateId });
+const TemplatesSaveWorkspaceRequestJson = /* @__PURE__ */ Schema.Struct({
+	expectedRevision: Schema.String,
+	expectedHead: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+	message: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(512).annotate({ expected: "a string with at most 512 code points" })).check(Schema.isMaxLength(512).annotate({ expected: "a value with a length of at most 512" })),
+	idempotencyKey: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" }))
+});
+const TemplatesSaveWorkspace200 = /* @__PURE__ */ Schema.Struct({
+	commit: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+	parentCommit: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+	tree: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{40}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{40}$" })),
+	revision: Schema.String,
+	changedPaths: Schema.Array(Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$)).{1,1024}$" }))),
+	sourceDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+	buildDigest: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^[a-f0-9]{64}$", "u")).annotate({ expected: "a string matching the RegExp ^[a-f0-9]{64}$" })),
+	warnings: Schema.Array(Schema.Struct({
+		code: Schema.String,
+		severity: Schema.Union([
+			Schema.Literal("error"),
+			Schema.Literal("warning"),
+			Schema.Literal("info")
+		]),
+		message: Schema.String,
+		origins: Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		})),
+		clients: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		notes: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		provenance: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		fixtures: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		occurrences: Schema.optionalKey(Schema.Union([Schema.Array(Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		}))), Schema.Null])),
+		compatibility: Schema.optionalKey(Schema.Union([Schema.Struct({
+			assessment: Schema.Union([
+				Schema.Literal("risk"),
+				Schema.Literal("degradation"),
+				Schema.Literal("unverified"),
+				Schema.Literal("not-applicable")
+			]),
+			title: Schema.String
+		}), Schema.Null]))
+	})),
+	incompatibilities: Schema.Array(Schema.Struct({
+		code: Schema.String,
+		severity: Schema.Union([
+			Schema.Literal("error"),
+			Schema.Literal("warning"),
+			Schema.Literal("info")
+		]),
+		message: Schema.String,
+		origins: Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		})),
+		clients: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		notes: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		provenance: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+		fixtures: Schema.optionalKey(Schema.Union([Schema.Array(Schema.String), Schema.Null])),
+		occurrences: Schema.optionalKey(Schema.Union([Schema.Array(Schema.Array(Schema.Struct({
+			fileName: Schema.String,
+			lineNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })),
+			columnNumber: Schema.Finite.check(Schema.isInt().annotate({ expected: "an integer" })).check(Schema.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" }))
+		}))), Schema.Null])),
+		compatibility: Schema.optionalKey(Schema.Union([Schema.Struct({
+			assessment: Schema.Union([
+				Schema.Literal("risk"),
+				Schema.Literal("degradation"),
+				Schema.Literal("unverified"),
+				Schema.Literal("not-applicable")
+			]),
+			title: Schema.String
+		}), Schema.Null]))
+	}))
+});
+const TemplatesSaveWorkspace401 = UnauthorizedError;
+const TemplatesSaveWorkspace403 = ForbiddenError;
+const TemplatesSaveWorkspace404 = ResourceNotFoundError;
+const TemplatesSaveWorkspace409 = ConflictError;
+const TemplatesSaveWorkspace422 = ValidationError;
+const TemplatesSaveWorkspace500 = InternalError;
+const TemplatesSaveWorkspace504 = GatewayTimeoutError;
+const TemplatesListFamiliesQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null]))
+});
+const TemplatesListFamilies200 = TemplateFamilyPage;
+const TemplatesListFamilies401 = UnauthorizedError;
+const TemplatesListFamilies403 = ForbiddenError;
+const TemplatesListFamilies422 = ValidationError;
+const TemplatesListFamilies500 = InternalError;
+const TemplatesListFamilies504 = GatewayTimeoutError;
+const TemplatesCreateFamilyRequestJson = /* @__PURE__ */ Schema.Struct({ name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })) });
+const TemplatesCreateFamily201 = TemplateFamily;
+const TemplatesCreateFamily401 = UnauthorizedError;
+const TemplatesCreateFamily403 = ForbiddenError;
+const TemplatesCreateFamily422 = ValidationError;
+const TemplatesCreateFamily500 = InternalError;
+const TemplatesCreateFamily504 = GatewayTimeoutError;
+const TemplatesGetFamilyPathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateFamilyId });
+const TemplatesGetFamily200 = TemplateFamily;
+const TemplatesGetFamily401 = UnauthorizedError;
+const TemplatesGetFamily403 = ForbiddenError;
+const TemplatesGetFamily404 = ResourceNotFoundError;
+const TemplatesGetFamily422 = ValidationError;
+const TemplatesGetFamily500 = InternalError;
+const TemplatesGetFamily504 = GatewayTimeoutError;
+const TemplatesDeleteFamilyPathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateFamilyId });
+const TemplatesDeleteFamily200 = SuccessResponse;
+const TemplatesDeleteFamily401 = UnauthorizedError;
+const TemplatesDeleteFamily403 = ForbiddenError;
+const TemplatesDeleteFamily404 = ResourceNotFoundError;
+const TemplatesDeleteFamily422 = ValidationError;
+const TemplatesDeleteFamily500 = InternalError;
+const TemplatesDeleteFamily504 = GatewayTimeoutError;
+const TemplatesRenameFamilyPathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateFamilyId });
+const TemplatesRenameFamilyRequestJson = /* @__PURE__ */ Schema.Struct({ name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })) });
+const TemplatesRenameFamily200 = TemplateFamily;
+const TemplatesRenameFamily401 = UnauthorizedError;
+const TemplatesRenameFamily403 = ForbiddenError;
+const TemplatesRenameFamily404 = ResourceNotFoundError;
+const TemplatesRenameFamily422 = ValidationError;
+const TemplatesRenameFamily500 = InternalError;
+const TemplatesRenameFamily504 = GatewayTimeoutError;
+const TemplatesAttachFamilyMemberPathParams = /* @__PURE__ */ Schema.Struct({
+	id: TemplateFamilyId,
+	templateId: TemplateId
+});
+const TemplatesAttachFamilyMember200 = TemplateFamily;
+const TemplatesAttachFamilyMember401 = UnauthorizedError;
+const TemplatesAttachFamilyMember403 = ForbiddenError;
+const TemplatesAttachFamilyMember404 = ResourceNotFoundError;
+const TemplatesAttachFamilyMember409 = ConflictError;
+const TemplatesAttachFamilyMember422 = ValidationError;
+const TemplatesAttachFamilyMember500 = InternalError;
+const TemplatesAttachFamilyMember504 = GatewayTimeoutError;
+const TemplatesDetachFamilyMemberPathParams = /* @__PURE__ */ Schema.Struct({
+	id: TemplateFamilyId,
+	templateId: TemplateId
+});
+const TemplatesDetachFamilyMember200 = TemplateFamily;
+const TemplatesDetachFamilyMember401 = UnauthorizedError;
+const TemplatesDetachFamilyMember403 = ForbiddenError;
+const TemplatesDetachFamilyMember404 = ResourceNotFoundError;
+const TemplatesDetachFamilyMember409 = ConflictError;
+const TemplatesDetachFamilyMember422 = ValidationError;
+const TemplatesDetachFamilyMember500 = InternalError;
+const TemplatesDetachFamilyMember504 = GatewayTimeoutError;
+const TemplatesCreateFamilyFromTemplatePathParams = /* @__PURE__ */ Schema.Struct({ templateId: TemplateId });
+const TemplatesCreateFamilyFromTemplateRequestJson = /* @__PURE__ */ Schema.Struct({ name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })) });
+const TemplatesCreateFamilyFromTemplate201 = TemplateFamily;
+const TemplatesCreateFamilyFromTemplate401 = UnauthorizedError;
+const TemplatesCreateFamilyFromTemplate403 = ForbiddenError;
+const TemplatesCreateFamilyFromTemplate404 = ResourceNotFoundError;
+const TemplatesCreateFamilyFromTemplate409 = ConflictError;
+const TemplatesCreateFamilyFromTemplate422 = ValidationError;
+const TemplatesCreateFamilyFromTemplate500 = InternalError;
+const TemplatesCreateFamilyFromTemplate504 = GatewayTimeoutError;
+const TemplatesAddEntryPathParams = /* @__PURE__ */ Schema.Struct({ id: TemplateProjectId });
+const TemplatesAddEntryRequestJson = /* @__PURE__ */ Schema.Struct({
+	entryPath: Schema.String.check(Schema.isMaxCodePoints(1024).annotate({ expected: "a string with at most 1024 code points" })).check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$", "u")).annotate({ expected: "a string matching the RegExp ^(?!\\/)(?!.*\\\\)(?!.*(?:^|\\/)\\.{1,2}(?:\\/|$))(?!.*(?:^|\\/)\\.git(?:\\/|$))(?:templates|emails)\\/.+\\.tsx$" })).check(Schema.isMaxLength(1024).annotate({ expected: "a value with a length of at most 1024" })),
+	name: Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(200).annotate({ expected: "a string with at most 200 code points" })).check(Schema.isMaxLength(200).annotate({ expected: "a value with a length of at most 200" })),
+	slug: Schema.String.check(Schema.isPattern(/* @__PURE__ */ new RegExp("^(?=.{1,100}$)[a-z0-9]+(?:-[a-z0-9]+)*$", "u")).annotate({ expected: "a string matching the RegExp ^(?=.{1,100}$)[a-z0-9]+(?:-[a-z0-9]+)*$" })),
+	description: Schema.optionalKey(Schema.Union([Schema.Union([Schema.String, Schema.Null]), Schema.Null])),
+	category: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Union([
+		Schema.Literal("transactional"),
+		Schema.Literal("marketing"),
+		Schema.Literal("support"),
+		Schema.Literal("notification"),
+		Schema.Literal("verification"),
+		Schema.Literal("reminder"),
+		Schema.Literal("alert")
+	]), Schema.Null]), Schema.Null]))
+});
+const TemplatesAddEntry201 = Template;
+const TemplatesAddEntry401 = UnauthorizedError;
+const TemplatesAddEntry403 = ForbiddenError;
+const TemplatesAddEntry404 = ResourceNotFoundError;
+const TemplatesAddEntry409 = ConflictError;
+const TemplatesAddEntry422 = ValidationError;
+const TemplatesAddEntry500 = InternalError;
+const TemplatesAddEntry504 = GatewayTimeoutError;
+var TemplatesGroup = class extends HttpApiGroup.make("Templates").add(HttpApiEndpoint.get("templatesList", "/v1/templates", {
+	query: TemplatesListQuery,
+	success: TemplatesList200,
+	error: [
+		TemplatesList401.pipe(HttpApiSchema.status(401)),
+		TemplatesList403.pipe(HttpApiSchema.status(403)),
+		TemplatesList422.pipe(HttpApiSchema.status(422)),
+		TemplatesList500,
+		TemplatesList504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.list").annotate(OpenApi.Summary, "List templates").annotate(OpenApi.Description, "Returns template summaries, newest first, filterable by category, channel, status, project, and search. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page. Read a template's compiled content, current publication, and input schema with `GET /v1/templates/{id}`."), HttpApiEndpoint.post("templatesCreate", "/v1/templates", {
+	payload: TemplatesCreateRequestJson,
+	success: TemplatesCreate201.pipe(HttpApiSchema.status(201)),
+	error: [
+		TemplatesCreate401.pipe(HttpApiSchema.status(401)),
+		TemplatesCreate403.pipe(HttpApiSchema.status(403)),
+		TemplatesCreate409.pipe(HttpApiSchema.status(409)),
+		TemplatesCreate422.pipe(HttpApiSchema.status(422)),
+		TemplatesCreate500,
+		TemplatesCreate504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.create").annotate(OpenApi.Summary, "Create a template").annotate(OpenApi.Description, "Creates an email template project from Samva's canonical TSX starter and returns its template entry with status 201."), HttpApiEndpoint.get("templatesGetById", "/v1/templates/:id", {
+	params: TemplatesGetByIdPathParams,
+	success: TemplatesGetById200,
+	error: [
+		TemplatesGetById401.pipe(HttpApiSchema.status(401)),
+		TemplatesGetById403.pipe(HttpApiSchema.status(403)),
+		TemplatesGetById404.pipe(HttpApiSchema.status(404)),
+		TemplatesGetById422.pipe(HttpApiSchema.status(422)),
+		TemplatesGetById500,
+		TemplatesGetById504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.getById").annotate(OpenApi.Summary, "Get a template").annotate(OpenApi.Description, "Returns the template with its project entry path, delivery defaults, compiled channel content, current publication, and the input schema that publication validates against. Open live project files through the workspace API."), HttpApiEndpoint.delete("templatesRemove", "/v1/templates/:id", {
+	params: TemplatesRemovePathParams,
+	success: TemplatesRemove200,
+	error: [
+		TemplatesRemove401.pipe(HttpApiSchema.status(401)),
+		TemplatesRemove403.pipe(HttpApiSchema.status(403)),
+		TemplatesRemove404.pipe(HttpApiSchema.status(404)),
+		TemplatesRemove422.pipe(HttpApiSchema.status(422)),
+		TemplatesRemove500,
+		TemplatesRemove504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.remove").annotate(OpenApi.Summary, "Delete a template").annotate(OpenApi.Description, "Deletes a template from the organization and returns a success flag."), HttpApiEndpoint.patch("templatesUpdate", "/v1/templates/:id", {
+	params: TemplatesUpdatePathParams,
+	payload: TemplatesUpdateRequestJson,
+	success: TemplatesUpdate200,
+	error: [
+		TemplatesUpdate401.pipe(HttpApiSchema.status(401)),
+		TemplatesUpdate403.pipe(HttpApiSchema.status(403)),
+		TemplatesUpdate404.pipe(HttpApiSchema.status(404)),
+		TemplatesUpdate409.pipe(HttpApiSchema.status(409)),
+		TemplatesUpdate422.pipe(HttpApiSchema.status(422)),
+		TemplatesUpdate500,
+		TemplatesUpdate504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.update").annotate(OpenApi.Summary, "Update a template").annotate(OpenApi.Description, "Updates template metadata. Setting `entryPath` points the template at another file in its project and keeps its id, slug, and publications; move the file in Git separately. Source changes use the project workspace API."), HttpApiEndpoint.get("templatesListInputContracts", "/v1/templates/:id/input-contracts", {
+	params: TemplatesListInputContractsPathParams,
+	query: TemplatesListInputContractsQuery,
+	success: TemplatesListInputContracts200,
+	error: [
+		TemplatesListInputContracts401.pipe(HttpApiSchema.status(401)),
+		TemplatesListInputContracts403.pipe(HttpApiSchema.status(403)),
+		TemplatesListInputContracts404.pipe(HttpApiSchema.status(404)),
+		TemplatesListInputContracts422.pipe(HttpApiSchema.status(422)),
+		TemplatesListInputContracts500,
+		TemplatesListInputContracts504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.listInputContracts").annotate(OpenApi.Summary, "List a template's input contracts").annotate(OpenApi.Description, "Returns the immutable input contracts this template has published under, newest version first. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page. Send against a contract to follow later publications that validate input identically."), HttpApiEndpoint.get("templatesGetInputContract", "/v1/templates/:id/input-contracts/:inputContractId", {
+	params: TemplatesGetInputContractPathParams,
+	success: TemplatesGetInputContract200,
+	error: [
+		TemplatesGetInputContract401.pipe(HttpApiSchema.status(401)),
+		TemplatesGetInputContract403.pipe(HttpApiSchema.status(403)),
+		TemplatesGetInputContract404.pipe(HttpApiSchema.status(404)),
+		TemplatesGetInputContract422.pipe(HttpApiSchema.status(422)),
+		TemplatesGetInputContract500,
+		TemplatesGetInputContract504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.getInputContract").annotate(OpenApi.Summary, "Get a template input contract").annotate(OpenApi.Description, "Returns one immutable input contract and the published schema it validates against."), HttpApiEndpoint.post("templatesPublish", "/v1/templates/:id/publications", {
+	params: TemplatesPublishPathParams,
+	payload: TemplatesPublishRequestJson,
+	success: TemplatesPublish201.pipe(HttpApiSchema.status(201)),
+	error: [
+		TemplatesPublish401.pipe(HttpApiSchema.status(401)),
+		TemplatesPublish403.pipe(HttpApiSchema.status(403)),
+		TemplatesPublish404.pipe(HttpApiSchema.status(404)),
+		TemplatesPublish409.pipe(HttpApiSchema.status(409)),
+		TemplatesPublish422.pipe(HttpApiSchema.status(422)),
+		TemplatesPublish500,
+		TemplatesPublish504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.publish").annotate(OpenApi.Summary, "Publish an exact template commit").annotate(OpenApi.Description, "Builds an exact Git commit and entry path, stores the immutable compiled IR and its assets, records the input contract it validates against, and makes that publication current."), HttpApiEndpoint.get("templatesGetPublication", "/v1/templates/:id/publications/:publicationId", {
+	params: TemplatesGetPublicationPathParams,
+	success: TemplatesGetPublication200,
+	error: [
+		TemplatesGetPublication401.pipe(HttpApiSchema.status(401)),
+		TemplatesGetPublication403.pipe(HttpApiSchema.status(403)),
+		TemplatesGetPublication404.pipe(HttpApiSchema.status(404)),
+		TemplatesGetPublication422.pipe(HttpApiSchema.status(422)),
+		TemplatesGetPublication500,
+		TemplatesGetPublication504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.getPublication").annotate(OpenApi.Summary, "Get a template publication").annotate(OpenApi.Description, "Returns one immutable publication and its exact build receipt."), HttpApiEndpoint.post("templatesRenderPublication", "/v1/templates/:id/publications/:publicationId/render", {
+	params: TemplatesRenderPublicationPathParams,
+	payload: TemplatesRenderPublicationRequestJson,
+	success: TemplatesRenderPublication200,
+	error: [
+		TemplatesRenderPublication401.pipe(HttpApiSchema.status(401)),
+		TemplatesRenderPublication403.pipe(HttpApiSchema.status(403)),
+		TemplatesRenderPublication404.pipe(HttpApiSchema.status(404)),
+		TemplatesRenderPublication409.pipe(HttpApiSchema.status(409)),
+		TemplatesRenderPublication422.pipe(HttpApiSchema.status(422)),
+		TemplatesRenderPublication500,
+		TemplatesRenderPublication504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.renderPublication").annotate(OpenApi.Summary, "Render a template publication").annotate(OpenApi.Description, "Renders one immutable publication against the `data` you pass, formatted in the `locale` and `timeZone` you name as a send formats them, and returns the subject, preheader, HTML and plain text a send would produce. `data` is validated against the publication's input schema exactly as a send validates it; invalid input returns a validation error that names each failing field. Nothing is sent or stored. Unpublished workspace edits are never rendered: only a publication id renders."), HttpApiEndpoint.get("templatesGetGitRepository", "/v1/templates/:id/repository", {
+	params: TemplatesGetGitRepositoryPathParams,
+	success: TemplatesGetGitRepository200,
+	error: [
+		TemplatesGetGitRepository401.pipe(HttpApiSchema.status(401)),
+		TemplatesGetGitRepository403.pipe(HttpApiSchema.status(403)),
+		TemplatesGetGitRepository404.pipe(HttpApiSchema.status(404)),
+		TemplatesGetGitRepository409.pipe(HttpApiSchema.status(409)),
+		TemplatesGetGitRepository422.pipe(HttpApiSchema.status(422)),
+		TemplatesGetGitRepository500,
+		TemplatesGetGitRepository504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.getGitRepository").annotate(OpenApi.Summary, "Get a template project Git repository").annotate(OpenApi.Description, "Returns the credential-free HTTPS remote and default branch for the template project repository."), HttpApiEndpoint.post("templatesIssueGitCredential", "/v1/templates/:id/repository/credentials", {
+	params: TemplatesIssueGitCredentialPathParams,
+	payload: TemplatesIssueGitCredentialRequestJson,
+	success: TemplatesIssueGitCredential200,
+	error: [
+		TemplatesIssueGitCredential401.pipe(HttpApiSchema.status(401)),
+		TemplatesIssueGitCredential403.pipe(HttpApiSchema.status(403)),
+		TemplatesIssueGitCredential404.pipe(HttpApiSchema.status(404)),
+		TemplatesIssueGitCredential409.pipe(HttpApiSchema.status(409)),
+		TemplatesIssueGitCredential422.pipe(HttpApiSchema.status(422)),
+		TemplatesIssueGitCredential500,
+		TemplatesIssueGitCredential504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.issueGitCredential").annotate(OpenApi.Summary, "Issue a template project Git credential").annotate(OpenApi.Description, "Exchanges the caller's Samva authorization for a one-hour Git credential scoped to the template repository."), HttpApiEndpoint.post("templatesOpenWorkspace", "/v1/templates/:id/workspace", {
+	params: TemplatesOpenWorkspacePathParams,
+	success: TemplatesOpenWorkspace200,
+	error: [
+		TemplatesOpenWorkspace401.pipe(HttpApiSchema.status(401)),
+		TemplatesOpenWorkspace403.pipe(HttpApiSchema.status(403)),
+		TemplatesOpenWorkspace404.pipe(HttpApiSchema.status(404)),
+		TemplatesOpenWorkspace409.pipe(HttpApiSchema.status(409)),
+		TemplatesOpenWorkspace422.pipe(HttpApiSchema.status(422)),
+		TemplatesOpenWorkspace500,
+		TemplatesOpenWorkspace504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.openWorkspace").annotate(OpenApi.Summary, "Open a template project workspace").annotate(OpenApi.Description, "Creates or opens the shared project workspace at the latest saved version and returns its effective files."), HttpApiEndpoint.patch("templatesPatchWorkspace", "/v1/templates/:id/workspace", {
+	params: TemplatesPatchWorkspacePathParams,
+	payload: TemplatesPatchWorkspaceRequestJson,
+	success: TemplatesPatchWorkspace200,
+	error: [
+		TemplatesPatchWorkspace401.pipe(HttpApiSchema.status(401)),
+		TemplatesPatchWorkspace403.pipe(HttpApiSchema.status(403)),
+		TemplatesPatchWorkspace404.pipe(HttpApiSchema.status(404)),
+		TemplatesPatchWorkspace409.pipe(HttpApiSchema.status(409)),
+		TemplatesPatchWorkspace422.pipe(HttpApiSchema.status(422)),
+		TemplatesPatchWorkspace500,
+		TemplatesPatchWorkspace504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.patchWorkspace").annotate(OpenApi.Summary, "Patch template project files").annotate(OpenApi.Description, "Applies revision-checked file patches to the shared project workspace overlay."), HttpApiEndpoint.put("templatesPutWorkspaceAsset", "/v1/templates/:id/workspace/assets", {
+	params: TemplatesPutWorkspaceAssetPathParams,
+	payload: TemplatesPutWorkspaceAssetRequestJson,
+	success: TemplatesPutWorkspaceAsset200,
+	error: [
+		TemplatesPutWorkspaceAsset401.pipe(HttpApiSchema.status(401)),
+		TemplatesPutWorkspaceAsset403.pipe(HttpApiSchema.status(403)),
+		TemplatesPutWorkspaceAsset404.pipe(HttpApiSchema.status(404)),
+		TemplatesPutWorkspaceAsset409.pipe(HttpApiSchema.status(409)),
+		TemplatesPutWorkspaceAsset422.pipe(HttpApiSchema.status(422)),
+		TemplatesPutWorkspaceAsset500,
+		TemplatesPutWorkspaceAsset504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.putWorkspaceAsset").annotate(OpenApi.Summary, "Put a template project asset").annotate(OpenApi.Description, "Writes one image or font (png, jpg, jpeg, gif, webp, or woff2) into the shared project workspace as an unsaved file; Save commits it. The JSON body carries the file as canonical base64 in `contentBase64`, at most 1 MiB decoded, and the bytes must match the extension in `path`. `replace` must be `false` to add a new file and `true` to change an existing one."), HttpApiEndpoint.post("templatesCheckWorkspace", "/v1/templates/:id/workspace/check", {
+	params: TemplatesCheckWorkspacePathParams,
+	payload: TemplatesCheckWorkspaceRequestJson,
+	success: TemplatesCheckWorkspace200,
+	error: [
+		TemplatesCheckWorkspace401.pipe(HttpApiSchema.status(401)),
+		TemplatesCheckWorkspace403.pipe(HttpApiSchema.status(403)),
+		TemplatesCheckWorkspace404.pipe(HttpApiSchema.status(404)),
+		TemplatesCheckWorkspace409.pipe(HttpApiSchema.status(409)),
+		TemplatesCheckWorkspace422.pipe(HttpApiSchema.status(422)),
+		TemplatesCheckWorkspace500,
+		TemplatesCheckWorkspace504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.checkWorkspace").annotate(OpenApi.Summary, "Check a template project workspace").annotate(OpenApi.Description, "Builds the template entry from the current effective workspace tree, including unsaved file patches, and returns what the template declares plus every compile and target-client finding. Nothing is written and no message is rendered."), HttpApiEndpoint.post("templatesResolveWorkspaceConflict", "/v1/templates/:id/workspace/conflicts", {
+	params: TemplatesResolveWorkspaceConflictPathParams,
+	payload: TemplatesResolveWorkspaceConflictRequestJson,
+	success: TemplatesResolveWorkspaceConflict200,
+	error: [
+		TemplatesResolveWorkspaceConflict401.pipe(HttpApiSchema.status(401)),
+		TemplatesResolveWorkspaceConflict403.pipe(HttpApiSchema.status(403)),
+		TemplatesResolveWorkspaceConflict404.pipe(HttpApiSchema.status(404)),
+		TemplatesResolveWorkspaceConflict409.pipe(HttpApiSchema.status(409)),
+		TemplatesResolveWorkspaceConflict422.pipe(HttpApiSchema.status(422)),
+		TemplatesResolveWorkspaceConflict500,
+		TemplatesResolveWorkspaceConflict504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.resolveWorkspaceConflict").annotate(OpenApi.Summary, "Resolve a template workspace conflict").annotate(OpenApi.Description, "Resolves one conflicted file by keeping the draft, using main, or supplying edited source."), HttpApiEndpoint.post("templatesDiffWorkspace", "/v1/templates/:id/workspace/diff", {
+	params: TemplatesDiffWorkspacePathParams,
+	payload: TemplatesDiffWorkspaceRequestJson,
+	success: TemplatesDiffWorkspace200,
+	error: [
+		TemplatesDiffWorkspace401.pipe(HttpApiSchema.status(401)),
+		TemplatesDiffWorkspace403.pipe(HttpApiSchema.status(403)),
+		TemplatesDiffWorkspace404.pipe(HttpApiSchema.status(404)),
+		TemplatesDiffWorkspace409.pipe(HttpApiSchema.status(409)),
+		TemplatesDiffWorkspace422.pipe(HttpApiSchema.status(422)),
+		TemplatesDiffWorkspace500,
+		TemplatesDiffWorkspace504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.diffWorkspace").annotate(OpenApi.Summary, "Diff a template project workspace").annotate(OpenApi.Description, "Returns exact added, modified, and deleted project files against the current Git base commit."), HttpApiEndpoint.post("templatesRenderWorkspaceFixture", "/v1/templates/:id/workspace/fixtures", {
+	params: TemplatesRenderWorkspaceFixturePathParams,
+	payload: TemplatesRenderWorkspaceFixtureRequestJson,
+	success: TemplatesRenderWorkspaceFixture200,
+	error: [
+		TemplatesRenderWorkspaceFixture401.pipe(HttpApiSchema.status(401)),
+		TemplatesRenderWorkspaceFixture403.pipe(HttpApiSchema.status(403)),
+		TemplatesRenderWorkspaceFixture404.pipe(HttpApiSchema.status(404)),
+		TemplatesRenderWorkspaceFixture409.pipe(HttpApiSchema.status(409)),
+		TemplatesRenderWorkspaceFixture422.pipe(HttpApiSchema.status(422)),
+		TemplatesRenderWorkspaceFixture500,
+		TemplatesRenderWorkspaceFixture504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.renderWorkspaceFixture").annotate(OpenApi.Summary, "Render a declared template workspace fixture").annotate(OpenApi.Description, "Renders one of the named inputs the template declares against the current effective workspace tree. Only declared fixtures render here; arbitrary input renders against a publication."), HttpApiEndpoint.get("templatesWorkspaceHistory", "/v1/templates/:id/workspace/history", {
+	params: TemplatesWorkspaceHistoryPathParams,
+	query: TemplatesWorkspaceHistoryQuery,
+	success: TemplatesWorkspaceHistory200,
+	error: [
+		TemplatesWorkspaceHistory401.pipe(HttpApiSchema.status(401)),
+		TemplatesWorkspaceHistory403.pipe(HttpApiSchema.status(403)),
+		TemplatesWorkspaceHistory404.pipe(HttpApiSchema.status(404)),
+		TemplatesWorkspaceHistory409.pipe(HttpApiSchema.status(409)),
+		TemplatesWorkspaceHistory422.pipe(HttpApiSchema.status(422)),
+		TemplatesWorkspaceHistory500,
+		TemplatesWorkspaceHistory504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.workspaceHistory").annotate(OpenApi.Summary, "List template project commit history").annotate(OpenApi.Description, "Returns recent history from the template repository's default branch."), HttpApiEndpoint.post("templatesAttachWorkspaceResource", "/v1/templates/:id/workspace/resources", {
+	params: TemplatesAttachWorkspaceResourcePathParams,
+	payload: TemplatesAttachWorkspaceResourceRequestJson,
+	success: TemplatesAttachWorkspaceResource200,
+	error: [
+		TemplatesAttachWorkspaceResource401.pipe(HttpApiSchema.status(401)),
+		TemplatesAttachWorkspaceResource403.pipe(HttpApiSchema.status(403)),
+		TemplatesAttachWorkspaceResource404.pipe(HttpApiSchema.status(404)),
+		TemplatesAttachWorkspaceResource409.pipe(HttpApiSchema.status(409)),
+		TemplatesAttachWorkspaceResource422.pipe(HttpApiSchema.status(422)),
+		TemplatesAttachWorkspaceResource500,
+		TemplatesAttachWorkspaceResource504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.attachWorkspaceResource").annotate(OpenApi.Summary, "Attach a template workspace resource").annotate(OpenApi.Description, "Adds or replaces one bounded persistent read-only resource and advances the workspace revision."), HttpApiEndpoint.post("templatesRemoveWorkspaceResource", "/v1/templates/:id/workspace/resources/:resourceId/remove", {
+	params: TemplatesRemoveWorkspaceResourcePathParams,
+	payload: TemplatesRemoveWorkspaceResourceRequestJson,
+	success: TemplatesRemoveWorkspaceResource200,
+	error: [
+		TemplatesRemoveWorkspaceResource401.pipe(HttpApiSchema.status(401)),
+		TemplatesRemoveWorkspaceResource403.pipe(HttpApiSchema.status(403)),
+		TemplatesRemoveWorkspaceResource404.pipe(HttpApiSchema.status(404)),
+		TemplatesRemoveWorkspaceResource409.pipe(HttpApiSchema.status(409)),
+		TemplatesRemoveWorkspaceResource422.pipe(HttpApiSchema.status(422)),
+		TemplatesRemoveWorkspaceResource500,
+		TemplatesRemoveWorkspaceResource504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.removeWorkspaceResource").annotate(OpenApi.Summary, "Remove a template workspace resource").annotate(OpenApi.Description, "Removes one persistent resource from mounted context and advances the workspace revision."), HttpApiEndpoint.post("templatesRestoreWorkspace", "/v1/templates/:id/workspace/restore", {
+	params: TemplatesRestoreWorkspacePathParams,
+	payload: TemplatesRestoreWorkspaceRequestJson,
+	success: TemplatesRestoreWorkspace200,
+	error: [
+		TemplatesRestoreWorkspace401.pipe(HttpApiSchema.status(401)),
+		TemplatesRestoreWorkspace403.pipe(HttpApiSchema.status(403)),
+		TemplatesRestoreWorkspace404.pipe(HttpApiSchema.status(404)),
+		TemplatesRestoreWorkspace409.pipe(HttpApiSchema.status(409)),
+		TemplatesRestoreWorkspace422.pipe(HttpApiSchema.status(422)),
+		TemplatesRestoreWorkspace500,
+		TemplatesRestoreWorkspace504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.restoreWorkspace").annotate(OpenApi.Summary, "Stage a historical template project tree").annotate(OpenApi.Description, "Builds the template entry before atomically staging a reachable historical commit and its emitted source; a later Save appends a new commit without rewriting branch history."), HttpApiEndpoint.post("templatesSaveWorkspace", "/v1/templates/:id/workspace/save", {
+	params: TemplatesSaveWorkspacePathParams,
+	payload: TemplatesSaveWorkspaceRequestJson,
+	success: TemplatesSaveWorkspace200,
+	error: [
+		TemplatesSaveWorkspace401.pipe(HttpApiSchema.status(401)),
+		TemplatesSaveWorkspace403.pipe(HttpApiSchema.status(403)),
+		TemplatesSaveWorkspace404.pipe(HttpApiSchema.status(404)),
+		TemplatesSaveWorkspace409.pipe(HttpApiSchema.status(409)),
+		TemplatesSaveWorkspace422.pipe(HttpApiSchema.status(422)),
+		TemplatesSaveWorkspace500,
+		TemplatesSaveWorkspace504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.saveWorkspace").annotate(OpenApi.Summary, "Save a template project workspace").annotate(OpenApi.Description, "Validates the effective project tree and saves it as one Git commit on the template repository's default branch."), HttpApiEndpoint.get("templatesListFamilies", "/v1/templates/families", {
+	query: TemplatesListFamiliesQuery,
+	success: TemplatesListFamilies200,
+	error: [
+		TemplatesListFamilies401.pipe(HttpApiSchema.status(401)),
+		TemplatesListFamilies403.pipe(HttpApiSchema.status(403)),
+		TemplatesListFamilies422.pipe(HttpApiSchema.status(422)),
+		TemplatesListFamilies500,
+		TemplatesListFamilies504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.listFamilies").annotate(OpenApi.Summary, "List template families").annotate(OpenApi.Description, "Returns the organization's template families with their members, newest first. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page."), HttpApiEndpoint.post("templatesCreateFamily", "/v1/templates/families", {
+	payload: TemplatesCreateFamilyRequestJson,
+	success: TemplatesCreateFamily201.pipe(HttpApiSchema.status(201)),
+	error: [
+		TemplatesCreateFamily401.pipe(HttpApiSchema.status(401)),
+		TemplatesCreateFamily403.pipe(HttpApiSchema.status(403)),
+		TemplatesCreateFamily422.pipe(HttpApiSchema.status(422)),
+		TemplatesCreateFamily500,
+		TemplatesCreateFamily504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.createFamily").annotate(OpenApi.Summary, "Create a template family").annotate(OpenApi.Description, "Creates an empty template family with the supplied name and returns it with status 201."), HttpApiEndpoint.get("templatesGetFamily", "/v1/templates/families/:id", {
+	params: TemplatesGetFamilyPathParams,
+	success: TemplatesGetFamily200,
+	error: [
+		TemplatesGetFamily401.pipe(HttpApiSchema.status(401)),
+		TemplatesGetFamily403.pipe(HttpApiSchema.status(403)),
+		TemplatesGetFamily404.pipe(HttpApiSchema.status(404)),
+		TemplatesGetFamily422.pipe(HttpApiSchema.status(422)),
+		TemplatesGetFamily500,
+		TemplatesGetFamily504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.getFamily").annotate(OpenApi.Summary, "Get a template family").annotate(OpenApi.Description, "Returns a template family and its channel-specific member templates."), HttpApiEndpoint.delete("templatesDeleteFamily", "/v1/templates/families/:id", {
+	params: TemplatesDeleteFamilyPathParams,
+	success: TemplatesDeleteFamily200,
+	error: [
+		TemplatesDeleteFamily401.pipe(HttpApiSchema.status(401)),
+		TemplatesDeleteFamily403.pipe(HttpApiSchema.status(403)),
+		TemplatesDeleteFamily404.pipe(HttpApiSchema.status(404)),
+		TemplatesDeleteFamily422.pipe(HttpApiSchema.status(422)),
+		TemplatesDeleteFamily500,
+		TemplatesDeleteFamily504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.deleteFamily").annotate(OpenApi.Summary, "Delete a template family").annotate(OpenApi.Description, "Deletes a template family without deleting its member templates."), HttpApiEndpoint.patch("templatesRenameFamily", "/v1/templates/families/:id", {
+	params: TemplatesRenameFamilyPathParams,
+	payload: TemplatesRenameFamilyRequestJson,
+	success: TemplatesRenameFamily200,
+	error: [
+		TemplatesRenameFamily401.pipe(HttpApiSchema.status(401)),
+		TemplatesRenameFamily403.pipe(HttpApiSchema.status(403)),
+		TemplatesRenameFamily404.pipe(HttpApiSchema.status(404)),
+		TemplatesRenameFamily422.pipe(HttpApiSchema.status(422)),
+		TemplatesRenameFamily500,
+		TemplatesRenameFamily504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.renameFamily").annotate(OpenApi.Summary, "Rename a template family").annotate(OpenApi.Description, "Changes a template family's name and returns the updated family."), HttpApiEndpoint.post("templatesAttachFamilyMember", "/v1/templates/families/:id/members/:templateId", {
+	params: TemplatesAttachFamilyMemberPathParams,
+	success: TemplatesAttachFamilyMember200,
+	error: [
+		TemplatesAttachFamilyMember401.pipe(HttpApiSchema.status(401)),
+		TemplatesAttachFamilyMember403.pipe(HttpApiSchema.status(403)),
+		TemplatesAttachFamilyMember404.pipe(HttpApiSchema.status(404)),
+		TemplatesAttachFamilyMember409.pipe(HttpApiSchema.status(409)),
+		TemplatesAttachFamilyMember422.pipe(HttpApiSchema.status(422)),
+		TemplatesAttachFamilyMember500,
+		TemplatesAttachFamilyMember504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.attachFamilyMember").annotate(OpenApi.Summary, "Attach a template to a family").annotate(OpenApi.Description, "Adds an existing template as a channel member of the family and returns the updated family."), HttpApiEndpoint.delete("templatesDetachFamilyMember", "/v1/templates/families/:id/members/:templateId", {
+	params: TemplatesDetachFamilyMemberPathParams,
+	success: TemplatesDetachFamilyMember200,
+	error: [
+		TemplatesDetachFamilyMember401.pipe(HttpApiSchema.status(401)),
+		TemplatesDetachFamilyMember403.pipe(HttpApiSchema.status(403)),
+		TemplatesDetachFamilyMember404.pipe(HttpApiSchema.status(404)),
+		TemplatesDetachFamilyMember409.pipe(HttpApiSchema.status(409)),
+		TemplatesDetachFamilyMember422.pipe(HttpApiSchema.status(422)),
+		TemplatesDetachFamilyMember500,
+		TemplatesDetachFamilyMember504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.detachFamilyMember").annotate(OpenApi.Summary, "Detach a template from a family").annotate(OpenApi.Description, "Removes a member template from the family without deleting the template."), HttpApiEndpoint.post("templatesCreateFamilyFromTemplate", "/v1/templates/families/from-template/:templateId", {
+	params: TemplatesCreateFamilyFromTemplatePathParams,
+	payload: TemplatesCreateFamilyFromTemplateRequestJson,
+	success: TemplatesCreateFamilyFromTemplate201.pipe(HttpApiSchema.status(201)),
+	error: [
+		TemplatesCreateFamilyFromTemplate401.pipe(HttpApiSchema.status(401)),
+		TemplatesCreateFamilyFromTemplate403.pipe(HttpApiSchema.status(403)),
+		TemplatesCreateFamilyFromTemplate404.pipe(HttpApiSchema.status(404)),
+		TemplatesCreateFamilyFromTemplate409.pipe(HttpApiSchema.status(409)),
+		TemplatesCreateFamilyFromTemplate422.pipe(HttpApiSchema.status(422)),
+		TemplatesCreateFamilyFromTemplate500,
+		TemplatesCreateFamilyFromTemplate504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.createFamilyFromTemplate").annotate(OpenApi.Summary, "Create a family from a template").annotate(OpenApi.Description, "Creates a template family containing the specified template and returns the new family with status 201."), HttpApiEndpoint.post("templatesAddEntry", "/v1/templates/projects/:id/entries", {
+	params: TemplatesAddEntryPathParams,
+	payload: TemplatesAddEntryRequestJson,
+	success: TemplatesAddEntry201.pipe(HttpApiSchema.status(201)),
+	error: [
+		TemplatesAddEntry401.pipe(HttpApiSchema.status(401)),
+		TemplatesAddEntry403.pipe(HttpApiSchema.status(403)),
+		TemplatesAddEntry404.pipe(HttpApiSchema.status(404)),
+		TemplatesAddEntry409.pipe(HttpApiSchema.status(409)),
+		TemplatesAddEntry422.pipe(HttpApiSchema.status(422)),
+		TemplatesAddEntry500,
+		TemplatesAddEntry504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "templates.addEntry").annotate(OpenApi.Summary, "Add a template entry").annotate(OpenApi.Description, "Registers a `.tsx` file under `templates/` or `emails/` in an existing template project as its own template and returns it with status 201. The file does not need to exist yet; publishing fails until a commit contains it. Repeating the call with the same entry path, name, and slug returns the existing template.")).annotate(OpenApi.Description, "Git-backed email template projects, workspace editing, immutable publications, and delivery defaults") {};
+//#endregion
+//#region src/effect/templates.ts
+var templates_exports = /* @__PURE__ */ __exportAll({
+	CreatePayload: () => CreateTemplatePayload,
+	UpdatePayload: () => UpdateTemplatePayload,
+	addEntry: () => addEntry,
+	attachFamilyMember: () => attachFamilyMember,
+	attachWorkspaceResource: () => attachWorkspaceResource,
+	checkWorkspace: () => checkWorkspace,
+	create: () => create,
+	createFamily: () => createFamily,
+	createFamilyFromTemplate: () => createFamilyFromTemplate,
+	deleteFamily: () => deleteFamily,
+	detachFamilyMember: () => detachFamilyMember,
+	diffWorkspace: () => diffWorkspace,
+	getById: () => getById,
+	getFamily: () => getFamily,
+	getGitRepository: () => getGitRepository,
+	getInputContract: () => getInputContract,
+	getPublication: () => getPublication,
+	issueGitCredential: () => issueGitCredential,
+	list: () => list,
+	listFamilies: () => listFamilies,
+	listInputContracts: () => listInputContracts,
+	openWorkspace: () => openWorkspace,
+	patchWorkspace: () => patchWorkspace,
+	publish: () => publish,
+	putWorkspaceAsset: () => putWorkspaceAsset,
+	remove: () => remove,
+	removeWorkspaceResource: () => removeWorkspaceResource,
+	renameFamily: () => renameFamily,
+	renderPublication: () => renderPublication,
+	renderWorkspaceFixture: () => renderWorkspaceFixture,
+	resolveWorkspaceConflict: () => resolveWorkspaceConflict,
+	restoreWorkspace: () => restoreWorkspace,
+	saveWorkspace: () => saveWorkspace,
+	update: () => update,
+	workspaceHistory: () => workspaceHistory
+});
+const make = forGroup(TemplatesGroup);
+const list = make("templatesList");
+const create = make("templatesCreate");
+const addEntry = make("templatesAddEntry");
+const listFamilies = make("templatesListFamilies");
+const createFamily = make("templatesCreateFamily");
+const getFamily = make("templatesGetFamily");
+const deleteFamily = make("templatesDeleteFamily");
+const renameFamily = make("templatesRenameFamily");
+const createFamilyFromTemplate = make("templatesCreateFamilyFromTemplate");
+const attachFamilyMember = make("templatesAttachFamilyMember");
+const detachFamilyMember = make("templatesDetachFamilyMember");
+const getById = make("templatesGetById");
+const remove = make("templatesRemove");
+const update = make("templatesUpdate");
+const openWorkspace = make("templatesOpenWorkspace");
+const getGitRepository = make("templatesGetGitRepository");
+const issueGitCredential = make("templatesIssueGitCredential");
+const patchWorkspace = make("templatesPatchWorkspace");
+const putWorkspaceAsset = make("templatesPutWorkspaceAsset");
+const resolveWorkspaceConflict = make("templatesResolveWorkspaceConflict");
+const attachWorkspaceResource = make("templatesAttachWorkspaceResource");
+const removeWorkspaceResource = make("templatesRemoveWorkspaceResource");
+const restoreWorkspace = make("templatesRestoreWorkspace");
+const saveWorkspace = make("templatesSaveWorkspace");
+const checkWorkspace = make("templatesCheckWorkspace");
+const renderWorkspaceFixture = make("templatesRenderWorkspaceFixture");
+const publish = make("templatesPublish");
+const getPublication = make("templatesGetPublication");
+const renderPublication = make("templatesRenderPublication");
+const listInputContracts = make("templatesListInputContracts");
+const getInputContract = make("templatesGetInputContract");
+const diffWorkspace = make("templatesDiffWorkspace");
+const workspaceHistory = make("templatesWorkspaceHistory");
+//#endregion
+export { restoreWorkspace as A, putWorkspaceAsset as C, renderPublication as D, renameFamily as E, templates_exports as M, update as N, renderWorkspaceFixture as O, workspaceHistory as P, publish as S, removeWorkspaceResource as T, list as _, create as a, openWorkspace as b, deleteFamily as c, getById as d, getFamily as f, issueGitCredential as g, getPublication as h, checkWorkspace as i, saveWorkspace as j, resolveWorkspaceConflict as k, detachFamilyMember as l, getInputContract as m, attachFamilyMember as n, createFamily as o, getGitRepository as p, attachWorkspaceResource as r, createFamilyFromTemplate as s, addEntry as t, diffWorkspace as u, listFamilies as v, remove as w, patchWorkspace as x, listInputContracts as y };
+
+//# sourceMappingURL=templates-DZomxsG7.js.map