@phtngyn/cms 0.1.0-beta.1 → 0.1.0-beta.3

package/src/StudioHttp-jR2-bc01.js

@@ -1,718 +0,0 @@
-import { c as STUDIO_API_PATH } from "./HttpPaths-BbS21Jy8.js";
-import { A as RemoveDocumentInput, B as StudioActor, D as PublishedDocumentPage, E as PublishedDocumentLookup, F as AccessDenied, I as AuthenticationRequired, K as MediaCleanupReport, M as UndeleteDocumentInput, O as PublishedDocumentQuery, P as UpdateDocumentInput, Q as MediaInvalid, S as DuplicateDocumentInput, T as PublishDocumentInput, Tt as nonNegativeInt, V as StudioEntryDenied, W as MediaAsset, X as MediaId, Y as MediaFolder, Z as MediaIntegrityReport, _ as DocumentSource, _t as DocumentVersion, at as MediaReferenced, b as DocumentSurround, ct as MediaUpload, d as DocumentIssue, et as MediaNotFound, f as DocumentMutationResult, g as DocumentRevisionAction, gt as DocumentId, ht as DocumentHistoryCursor, i as CreateDocumentInput, j as RestoreDocumentInput, k as PublishedDocumentSurroundQuery, m as DocumentNavigationQuery, n as CmsMarkdownDocument, nt as MediaPage, o as DeletedDocument, p as DocumentNavigationItem, pt as RequestId, q as MediaConflict, r as CompiledDocument, rt as MediaQuery, s as DocumentBrowseQuery, st as MediaTooLarge, tt as MediaObjectKey, w as MoveDocumentInput, wt as SourcePath, x as DocumentValidationResult, xt as RevisionId, y as DocumentSummary, yt as PublicPath, z as Role } from "./models-BkMgeaOL.js";
-import { i as MediaConfiguration, r as DocumentConfiguration } from "./Configuration-DyKo0sLS.js";
-import { Context, Schema } from "effect";
-import { Multipart } from "effect/unstable/http";
-import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/unstable/httpapi";
-
-//#region ../protocol/src/internal/documents/errors.ts
-var DocumentNotFound = class extends Schema.TaggedError()("Document.NotFound", {
-	documentId: DocumentId,
-	revisionId: Schema.optionalKey(RevisionId)
-}) {};
-var DocumentPathConflict = class extends Schema.TaggedError()("Document.PathConflict", { sourcePath: SourcePath }) {};
-var DocumentVersionConflict = class extends Schema.TaggedError()("Document.VersionConflict", {
-	documentId: DocumentId,
-	expectedVersion: DocumentVersion,
-	actualVersion: DocumentVersion
-}) {};
-var DocumentMediaUnavailable = class extends Schema.TaggedError()("Document.MediaUnavailable", {
-	documentId: DocumentId,
-	mediaKeys: Schema.Array(MediaObjectKey).check(Schema.isMinLength(1))
-}) {};
-var DocumentValidationFailed = class extends Schema.TaggedError()("Document.ValidationFailed", { issues: Schema.Array(DocumentIssue) }) {};
-var PublishedDocumentNotFound = class extends Schema.TaggedError()("PublishedDocument.NotFound", { lookup: PublishedDocumentLookup }) {};
-
-//#endregion
-//#region ../protocol/src/Activity.ts
-/**
-* Immutable completed Activity facts. Pages are ordered newest-first; cursors are opaque,
-* stable continuation tokens and an invalid cursor is a caller-visible failure.
-*/
-const ActivityId = Schema.String.check(Schema.isUUID()).pipe(Schema.brand("ActivityId"));
-const ActivityCursor = Schema.NonEmptyString.pipe(Schema.brand("ActivityCursor"));
-const ACTIVITY_ACTIONS = [
-	"document.created",
-	"document.updated",
-	"document.moved",
-	"document.trashed",
-	"document.revision.restored",
-	"document.untrashed",
-	"document.published",
-	"document.unpublished",
-	"media.uploaded",
-	"media.replaced",
-	"media.removed",
-	"media.cleaned",
-	"user.created",
-	"user.removed",
-	"user.role.changed",
-	"user.sessions.revoked",
-	"authentication.signed-in",
-	"authentication.signed-out",
-	"authentication.password.changed",
-	"authentication.password.reset"
-];
-const ActivityAction = Schema.Literals(ACTIVITY_ACTIONS);
-const DocumentActivityTarget = Schema.Struct({
-	kind: Schema.tag("document"),
-	documentId: DocumentId
-});
-const MediaActivityTarget = Schema.Struct({
-	kind: Schema.tag("media"),
-	mediaId: MediaId
-});
-const MediaLibraryActivityTarget = Schema.Struct({ kind: Schema.tag("media-library") });
-const ActivityTarget = Schema.Union([
-	DocumentActivityTarget,
-	MediaActivityTarget,
-	MediaLibraryActivityTarget,
-	Schema.Struct({
-		kind: Schema.tag("user"),
-		userId: Schema.NonEmptyString
-	})
-]).pipe(Schema.toTaggedUnion("kind"));
-const ActivityTargetKind = Schema.Literals([
-	"document",
-	"media",
-	"media-library",
-	"user"
-]);
-const ActivityContext = Schema.Struct({
-	actor: StudioActor,
-	requestId: RequestId,
-	reason: Schema.optionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(1e3)))
-}).annotate({ identifier: "ActivityContext" });
-const ActivityEntry = Schema.Struct({
-	id: ActivityId,
-	action: ActivityAction,
-	actor: StudioActor,
-	requestId: RequestId,
-	reason: ActivityContext.fields.reason,
-	target: ActivityTarget,
-	details: Schema.JsonObject,
-	occurredAt: Schema.DateTimeUtcFromString
-}).annotate({ identifier: "ActivityEntry" });
-const ActivityEntryDraft = Schema.Struct({
-	action: ActivityAction,
-	context: ActivityContext,
-	target: ActivityTarget,
-	details: Schema.JsonObject
-}).annotate({ identifier: "ActivityEntryDraft" });
-const ActivityQuery = Schema.Struct({
-	action: Schema.optionalKey(ActivityAction),
-	actorId: Schema.optionalKey(StudioActor.fields.id),
-	cursor: Schema.optionalKey(ActivityCursor),
-	limit: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 100
-	}))),
-	requestId: Schema.optionalKey(RequestId),
-	targetId: Schema.optionalKey(Schema.NonEmptyString),
-	targetKind: Schema.optionalKey(ActivityTargetKind)
-}).annotate({ identifier: "ActivityQuery" });
-const ActivityPage = Schema.Struct({
-	entries: Schema.Array(ActivityEntry),
-	nextCursor: Schema.optionalKey(ActivityCursor),
-	total: nonNegativeInt
-}).annotate({ identifier: "ActivityPage" });
-var ActivityCursorInvalid = class extends Schema.TaggedError()("Activity.CursorInvalid", {}) {};
-
-//#endregion
-//#region ../protocol/src/internal/documents/history.ts
-const DocumentRevisionSummary = Schema.Struct({
-	action: DocumentRevisionAction,
-	activity: ActivityEntry,
-	createdAt: Schema.DateTimeUtcFromString,
-	documentId: DocumentId,
-	revisionId: RevisionId,
-	sourcePath: SourcePath,
-	version: DocumentVersion
-}).annotate({ identifier: "DocumentRevisionSummary" });
-const DocumentRevision = Schema.Struct({
-	...DocumentRevisionSummary.fields,
-	markdown: Schema.String
-}).annotate({ identifier: "DocumentRevision" });
-const DocumentHistoryQuery = Schema.Struct({
-	documentId: DocumentId,
-	cursor: Schema.optionalKey(DocumentHistoryCursor),
-	limit: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 100
-	})))
-}).annotate({ identifier: "DocumentHistoryQuery" });
-const DocumentRevisionPage = Schema.Struct({
-	revisions: Schema.Array(DocumentRevisionSummary),
-	nextCursor: Schema.optionalKey(DocumentHistoryCursor),
-	total: nonNegativeInt
-}).annotate({ identifier: "DocumentRevisionPage" });
-const LineNumber = Schema.Int.check(Schema.isGreaterThan(0));
-const DocumentRevisionChange = Schema.Union([
-	Schema.Struct({
-		kind: Schema.tag("equal"),
-		beforeLine: LineNumber,
-		afterLine: LineNumber,
-		line: Schema.String
-	}),
-	Schema.Struct({
-		kind: Schema.tag("added"),
-		afterLine: LineNumber,
-		line: Schema.String
-	}),
-	Schema.Struct({
-		kind: Schema.tag("removed"),
-		beforeLine: LineNumber,
-		line: Schema.String
-	})
-]).pipe(Schema.toTaggedUnion("kind"));
-const CompareDocumentRevisionsInput = Schema.Struct({
-	documentId: DocumentId,
-	fromRevisionId: RevisionId,
-	toRevisionId: RevisionId
-}).annotate({ identifier: "CompareDocumentRevisionsInput" });
-const DocumentRevisionComparison = Schema.Struct({
-	from: DocumentRevision,
-	to: DocumentRevision,
-	changes: Schema.Array(DocumentRevisionChange)
-}).annotate({ identifier: "DocumentRevisionComparison" });
-var DocumentHistoryInvalidCursor = class extends Schema.TaggedError()("DocumentHistory.InvalidCursor", {}) {};
-var DocumentHistoryComparisonTooLarge = class extends Schema.TaggedError()("DocumentHistory.ComparisonTooLarge", {
-	maximumEditLength: Schema.Int.check(Schema.isGreaterThan(0)),
-	maximumLines: Schema.Int.check(Schema.isGreaterThan(0))
-}) {};
-
-//#endregion
-//#region ../protocol/src/Collaboration.ts
-/**
-* Collaboration handshake and WebSocket envelopes. Command results correlate by RequestId;
-* checkpoints carry the durable state vector needed for retry and recovery.
-*/
-const StateVector = Schema.String.check(Schema.isBase64()).pipe(Schema.brand("StateVector"));
-const HttpErrorStatus = Schema.Int.check(Schema.isBetween({
-	minimum: 400,
-	maximum: 599
-}));
-const CollaborationUser = Schema.Struct({
-	color: Schema.NonEmptyString,
-	id: Schema.NonEmptyString,
-	name: Schema.NonEmptyString
-});
-const CollaborationTicket = Schema.Struct({
-	authoringRevision: Schema.NonEmptyString,
-	authoredStateVector: StateVector,
-	documentName: Schema.NonEmptyString,
-	source: DocumentSource,
-	token: Schema.NonEmptyString,
-	url: Schema.NonEmptyString,
-	user: CollaborationUser,
-	workingStateVector: StateVector
-}).annotate({ identifier: "CollaborationTicket" });
-const CollaborationPreview = DocumentValidationResult.pipe(Schema.fieldsAssign({
-	markdown: Schema.String,
-	preview: Schema.Struct({
-		body: CmsMarkdownDocument,
-		fallbacks: Schema.Record(Schema.String, Schema.String)
-	})
-})).annotate({ identifier: "CollaborationPreview" });
-const CheckpointMessage = Schema.Struct({ type: Schema.tag("checkpoint") });
-const PreviewMessage = Schema.Struct({
-	type: Schema.tag("preview"),
-	requestId: RequestId
-});
-const PublishMessage = Schema.Struct({
-	type: Schema.tag("publish"),
-	requestId: RequestId
-});
-const CollaborationClientMessage = Schema.Union([
-	CheckpointMessage,
-	PreviewMessage,
-	PublishMessage
-]).pipe(Schema.toTaggedUnion("type"));
-const requestFailure = {
-	error: Schema.NonEmptyString,
-	statusCode: HttpErrorStatus
-};
-const RequestFailure = Schema.Struct({
-	status: Schema.tag("failure"),
-	...requestFailure
-});
-const PreviewOutcome = Schema.Union([Schema.Struct({
-	status: Schema.tag("success"),
-	result: CollaborationPreview
-}), RequestFailure]).pipe(Schema.toTaggedUnion("status"));
-const PublishCheckpoint = Schema.Struct({
-	authoredStateVector: StateVector,
-	result: Schema.optionalKey(DocumentMutationResult)
-});
-const PublishOutcome = Schema.Union([Schema.Struct({
-	status: Schema.tag("success"),
-	authoredStateVector: StateVector,
-	result: DocumentMutationResult
-}), Schema.Struct({
-	status: Schema.tag("failure"),
-	...requestFailure,
-	checkpoint: Schema.optionalKey(PublishCheckpoint)
-})]).pipe(Schema.toTaggedUnion("status"));
-const WorkingSavedMessage = Schema.Struct({
-	type: Schema.tag("working-saved"),
-	workingStateVector: StateVector
-});
-const WorkingSaveErrorMessage = Schema.Struct({
-	type: Schema.tag("working-save-error"),
-	error: Schema.NonEmptyString
-});
-const PreviewResultMessage = Schema.Struct({
-	type: Schema.tag("preview-result"),
-	requestId: RequestId,
-	outcome: PreviewOutcome
-});
-const PublishResultMessage = Schema.Struct({
-	type: Schema.tag("publish-result"),
-	requestId: RequestId,
-	outcome: PublishOutcome
-});
-const CollaborationServerMessage = Schema.Union([
-	WorkingSavedMessage,
-	WorkingSaveErrorMessage,
-	PreviewResultMessage,
-	PublishResultMessage
-]).pipe(Schema.toTaggedUnion("type"));
-
-//#endregion
-//#region ../protocol/src/Users.ts
-/**
-* User administration inputs, offset-paginated directory results, and caller-visible command
-* failures. Commands carry no idempotency key; clients resolve ambiguous outcomes by listing again.
-*/
-const UserEmail = Schema.NonEmptyString.check(Schema.isMaxLength(320), Schema.isPattern(/^[^\s@]+@[^\s@]+\.[^\s@]+$/u)).annotate({ identifier: "UserEmail" });
-const UserName = Schema.NonEmptyString.check(Schema.isMaxLength(200)).annotate({ identifier: "UserName" });
-const UserPassword = Schema.NonEmptyString.check(Schema.isMinLength(8), Schema.isMaxLength(200)).annotate({ identifier: "UserPassword" });
-const User = Schema.Struct({
-	id: Schema.NonEmptyString,
-	email: UserEmail,
-	name: UserName,
-	role: Role,
-	emailVerified: Schema.Boolean,
-	banned: Schema.Boolean,
-	createdAt: Schema.DateTimeUtcFromString,
-	updatedAt: Schema.DateTimeUtcFromString
-}).annotate({ identifier: "User" });
-const UserPage = Schema.Struct({
-	users: Schema.Array(User),
-	total: nonNegativeInt
-}).annotate({ identifier: "UserPage" });
-const UserQuery = Schema.Struct({
-	limit: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 100
-	}))),
-	offset: Schema.optionalKey(nonNegativeInt),
-	search: Schema.optionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(200)))
-}).annotate({ identifier: "UserQuery" });
-const CreateUserInput = Schema.Struct({
-	email: UserEmail,
-	name: UserName,
-	password: UserPassword,
-	role: Role
-}).annotate({ identifier: "CreateUserInput" });
-var UserAlreadyExists = class extends Schema.TaggedError()("User.AlreadyExists", { email: UserEmail }) {};
-var UserNotFound = class extends Schema.TaggedError()("User.NotFound", { userId: User.fields.id }) {};
-var UserSelfRemovalDenied = class extends Schema.TaggedError()("User.SelfRemovalDenied", { userId: User.fields.id }) {};
-var UserSelfRoleChangeDenied = class extends Schema.TaggedError()("User.SelfRoleChangeDenied", { userId: User.fields.id }) {};
-var UserAdministrationDenied = class extends Schema.TaggedError()("UserAdministration.Denied", {}) {};
-
-//#endregion
-//#region ../protocol/src/Initialization.ts
-/** Exclusive first-installation claim input, state, and caller-visible rejection failures. */
-const InitializationInput = Schema.Struct({
-	email: UserEmail,
-	initializationToken: Schema.NonEmptyString.check(Schema.isMaxLength(512)),
-	name: UserName,
-	password: UserPassword
-}).annotate({ identifier: "InitializationInput" });
-const InitializationState = Schema.Struct({ needsAdministrator: Schema.Boolean }).annotate({ identifier: "InitializationState" });
-var InitializationAlreadyCompleted = class extends Schema.TaggedError()("Initialization.AlreadyCompleted", {}) {};
-var InitializationProofInvalid = class extends Schema.TaggedError()("Initialization.ProofInvalid", {}) {};
-
-//#endregion
-//#region ../protocol/src/internal/http/failures.ts
-var StudioInternalError = class extends Schema.TaggedError()("Studio.InternalError", { message: Schema.Literal("The request could not be completed.") }) {};
-function studioInternalError() {
-	return new StudioInternalError({ message: "The request could not be completed." });
-}
-
-//#endregion
-//#region ../protocol/src/internal/http/delivery.ts
-const DeliverySurroundPayload = Schema.Struct({
-	lookup: PublishedDocumentLookup,
-	query: PublishedDocumentSurroundQuery
-}).annotate({ identifier: "DeliverySurroundPayload" });
-const InternalError$1 = StudioInternalError.pipe(HttpApiSchema.status(500));
-const PublishedNotFound = PublishedDocumentNotFound.pipe(HttpApiSchema.status(404));
-const Forbidden$1 = AccessDenied.pipe(HttpApiSchema.status(403));
-const PublishedDeliveryApi = HttpApiGroup.make("delivery").add(HttpApiEndpoint.post("read", "/read", {
-	payload: PublishedDocumentLookup,
-	success: CompiledDocument,
-	error: [PublishedNotFound, InternalError$1]
-}), HttpApiEndpoint.post("query", "/query", {
-	payload: PublishedDocumentQuery,
-	success: PublishedDocumentPage,
-	error: InternalError$1
-}), HttpApiEndpoint.post("navigation", "/navigation", {
-	payload: DocumentNavigationQuery,
-	success: Schema.Array(DocumentNavigationItem),
-	error: InternalError$1
-}), HttpApiEndpoint.post("surround", "/surround", {
-	payload: DeliverySurroundPayload,
-	success: DocumentSurround,
-	error: [PublishedNotFound, InternalError$1]
-})).prefix("/delivery");
-const PreviewDeliveryApi = HttpApiGroup.make("previewDelivery").add(HttpApiEndpoint.post("read", "/read", {
-	payload: PublishedDocumentLookup,
-	success: CompiledDocument,
-	error: [
-		PublishedNotFound,
-		InternalError$1,
-		Forbidden$1
-	]
-}), HttpApiEndpoint.post("query", "/query", {
-	payload: PublishedDocumentQuery,
-	success: PublishedDocumentPage,
-	error: [InternalError$1, Forbidden$1]
-}), HttpApiEndpoint.post("navigation", "/navigation", {
-	payload: DocumentNavigationQuery,
-	success: Schema.Array(DocumentNavigationItem),
-	error: [InternalError$1, Forbidden$1]
-}), HttpApiEndpoint.post("surround", "/surround", {
-	payload: DeliverySurroundPayload,
-	success: DocumentSurround,
-	error: [
-		PublishedNotFound,
-		InternalError$1,
-		Forbidden$1
-	]
-})).prefix("/preview");
-
-//#endregion
-//#region ../protocol/src/StudioHttp.ts
-/**
-* Studio HTTP paths, middleware contracts, payloads, and the composed CMS API. Every expected
-* caller failure is a tagged schema with an explicit status; unclassified failures become the
-* deliberately opaque `StudioInternalError`.
-*/
-const ApiVersion = Schema.NonEmptyString.pipe(Schema.brand("ApiVersion"));
-const StudioBootstrap = Schema.Struct({
-	basePath: PublicPath,
-	documents: DocumentConfiguration,
-	media: MediaConfiguration,
-	version: ApiVersion
-}).annotate({ identifier: "StudioBootstrap" });
-var StudioBadRequest = class extends Schema.TaggedError()("Studio.BadRequest", { kind: Schema.Literals([
-	"Headers",
-	"Params",
-	"Payload",
-	"Query"
-]) }) {};
-var StudioRequestConflict = class extends Schema.TaggedError()("Studio.RequestConflict", { retryable: Schema.Literal(true) }) {};
-var StudioSchemaError = class extends HttpApiMiddleware.Service()("@internal/protocol/StudioSchemaError", { error: [StudioBadRequest.pipe(HttpApiSchema.status(400)), StudioInternalError.pipe(HttpApiSchema.status(500))] }) {};
-var CurrentStudioRequest = class extends Context.Service()("@internal/protocol/CurrentStudioRequest") {};
-var StudioAuthentication = class extends HttpApiMiddleware.Service()("@internal/protocol/StudioAuthentication", { error: [
-	AuthenticationRequired.pipe(HttpApiSchema.status(401)),
-	StudioEntryDenied.pipe(HttpApiSchema.status(403)),
-	StudioInternalError.pipe(HttpApiSchema.status(500))
-] }) {};
-const UpdateDocumentPayload = Schema.Struct({
-	expectedVersion: UpdateDocumentInput.fields.expectedVersion,
-	markdown: UpdateDocumentInput.fields.markdown
-});
-const MoveDocumentPayload = Schema.Struct({
-	expectedVersion: MoveDocumentInput.fields.expectedVersion,
-	location: MoveDocumentInput.fields.location
-});
-const PublishDocumentPayload = Schema.Struct({ expectedVersion: PublishDocumentInput.fields.expectedVersion });
-const RemoveDocumentPayload = Schema.Struct({ expectedVersion: RemoveDocumentInput.fields.expectedVersion });
-const RestoreDocumentPayload = Schema.Struct({
-	expectedVersion: RestoreDocumentInput.fields.expectedVersion,
-	revisionId: RestoreDocumentInput.fields.revisionId
-});
-const UndeleteDocumentPayload = Schema.Struct({ expectedVersion: UndeleteDocumentInput.fields.expectedVersion });
-const ChangeRolePayload = Schema.Struct({ role: Role }).annotate({ identifier: "ChangeRolePayload" });
-const MediaUploadQuery = Schema.Struct({
-	declaredByteSize: MediaUpload.fields.declaredByteSize,
-	folder: Schema.optionalKey(MediaFolder)
-}).annotate({ identifier: "MediaUploadQuery" });
-const MediaUploadPayload = Schema.Struct({ file: Multipart.SingleFileSchema }).pipe(HttpApiSchema.asMultipartStream({ maxParts: 1 }));
-const NotFound = DocumentNotFound.pipe(HttpApiSchema.status(404));
-const VersionConflict = DocumentVersionConflict.pipe(HttpApiSchema.status(409));
-const Conflict = Schema.Union([
-	DocumentMediaUnavailable,
-	DocumentPathConflict,
-	DocumentVersionConflict
-]).pipe(HttpApiSchema.status(409));
-const ValidationFailed = DocumentValidationFailed.pipe(HttpApiSchema.status(422));
-const RequestConflict = StudioRequestConflict.pipe(HttpApiSchema.status(409));
-const InternalError = StudioInternalError.pipe(HttpApiSchema.status(500));
-const Forbidden = AccessDenied.pipe(HttpApiSchema.status(403));
-const MutationErrors = [
-	NotFound,
-	Conflict,
-	ValidationFailed,
-	RequestConflict,
-	Forbidden,
-	InternalError
-];
-const MediaNotFoundResponse = MediaNotFound.pipe(HttpApiSchema.status(404));
-const MediaInvalidQuery = MediaInvalid.pipe(HttpApiSchema.status(400));
-const MediaInvalidUpload = MediaInvalid.pipe(HttpApiSchema.status(422));
-const MediaTooLargeResponse = MediaTooLarge.pipe(HttpApiSchema.status(413));
-const MediaReferencedResponse = MediaReferenced.pipe(HttpApiSchema.status(409));
-const MediaConflictResponse = MediaConflict.pipe(HttpApiSchema.status(409));
-const InvalidActivityCursor = ActivityCursorInvalid.pipe(HttpApiSchema.status(400));
-const InvalidHistoryCursor = DocumentHistoryInvalidCursor.pipe(HttpApiSchema.status(400));
-const HistoryComparisonTooLarge = DocumentHistoryComparisonTooLarge.pipe(HttpApiSchema.status(422));
-const AlreadyInitialized = InitializationAlreadyCompleted.pipe(HttpApiSchema.status(409));
-const InitializationProofRejected = InitializationProofInvalid.pipe(HttpApiSchema.status(403));
-const UserAdministrationForbidden = UserAdministrationDenied.pipe(HttpApiSchema.status(403));
-const UserDuplicate = UserAlreadyExists.pipe(HttpApiSchema.status(409));
-const MissingUser = UserNotFound.pipe(HttpApiSchema.status(404));
-const UserSelfRemoval = UserSelfRemovalDenied.pipe(HttpApiSchema.status(409));
-const UserSelfRoleChange = UserSelfRoleChangeDenied.pipe(HttpApiSchema.status(409));
-const StudioDocumentsApi = HttpApiGroup.make("documents").add(HttpApiEndpoint.get("browse", "/", {
-	query: DocumentBrowseQuery,
-	success: Schema.Array(DocumentSummary),
-	error: [Forbidden, InternalError]
-}), HttpApiEndpoint.get("trash", "/trash", {
-	success: Schema.Array(DeletedDocument),
-	error: [Forbidden, InternalError]
-}), HttpApiEndpoint.get("read", "/:documentId", {
-	params: { documentId: DocumentId },
-	success: DocumentSource,
-	error: [
-		NotFound,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("create", "/", {
-	payload: CreateDocumentInput,
-	success: DocumentMutationResult.pipe(HttpApiSchema.status(201)),
-	error: MutationErrors
-}), HttpApiEndpoint.put("update", "/:documentId", {
-	params: { documentId: DocumentId },
-	payload: UpdateDocumentPayload,
-	success: DocumentMutationResult,
-	error: MutationErrors
-}), HttpApiEndpoint.post("validate", "/:documentId/validate", {
-	params: { documentId: DocumentId },
-	payload: UpdateDocumentPayload,
-	success: DocumentValidationResult,
-	error: [
-		NotFound,
-		VersionConflict,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("move", "/:documentId/move", {
-	params: { documentId: DocumentId },
-	payload: MoveDocumentPayload,
-	success: DocumentMutationResult,
-	error: MutationErrors
-}), HttpApiEndpoint.post("duplicate", "/:documentId/duplicate", {
-	params: { documentId: DocumentId },
-	payload: Schema.Struct({
-		...MoveDocumentPayload.fields,
-		includeChildren: DuplicateDocumentInput.fields.includeChildren
-	}),
-	success: DocumentMutationResult,
-	error: MutationErrors
-}), HttpApiEndpoint.post("unpublish", "/:documentId/unpublish", {
-	params: { documentId: DocumentId },
-	payload: PublishDocumentPayload,
-	success: DocumentMutationResult,
-	error: MutationErrors
-}), HttpApiEndpoint.post("publish", "/:documentId/publish", {
-	params: { documentId: DocumentId },
-	payload: PublishDocumentPayload,
-	success: DocumentMutationResult,
-	error: MutationErrors
-}), HttpApiEndpoint.post("remove", "/:documentId/remove", {
-	params: { documentId: DocumentId },
-	payload: RemoveDocumentPayload,
-	success: DocumentMutationResult,
-	error: MutationErrors
-}), HttpApiEndpoint.post("restore", "/:documentId/restore", {
-	params: { documentId: DocumentId },
-	payload: RestoreDocumentPayload,
-	success: DocumentMutationResult,
-	error: MutationErrors
-}), HttpApiEndpoint.post("undelete", "/:documentId/undelete", {
-	params: { documentId: DocumentId },
-	payload: UndeleteDocumentPayload,
-	success: DocumentMutationResult,
-	error: MutationErrors
-})).middleware(StudioAuthentication).prefix("/documents");
-const StudioMediaApi = HttpApiGroup.make("media").add(HttpApiEndpoint.get("search", "/", {
-	query: MediaQuery,
-	success: MediaPage,
-	error: [
-		MediaInvalidQuery,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("upload", "/", {
-	query: MediaUploadQuery,
-	payload: MediaUploadPayload,
-	success: MediaAsset.pipe(HttpApiSchema.status(201)),
-	error: [
-		MediaInvalidUpload,
-		MediaTooLargeResponse,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.put("replace", "/:mediaId", {
-	params: { mediaId: MediaId },
-	query: MediaUploadQuery,
-	payload: MediaUploadPayload,
-	success: MediaAsset,
-	error: [
-		MediaNotFoundResponse,
-		MediaConflictResponse,
-		MediaInvalidUpload,
-		MediaTooLargeResponse,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("cleanup", "/cleanup", {
-	success: MediaCleanupReport,
-	error: [Forbidden, InternalError]
-}), HttpApiEndpoint.get("integrity", "/integrity", {
-	success: MediaIntegrityReport,
-	error: [Forbidden, InternalError]
-}), HttpApiEndpoint.get("get", "/:mediaId", {
-	params: { mediaId: MediaId },
-	success: MediaAsset,
-	error: [
-		MediaNotFoundResponse,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.delete("remove", "/:mediaId", {
-	params: { mediaId: MediaId },
-	success: HttpApiSchema.NoContent,
-	error: [
-		MediaNotFoundResponse,
-		MediaConflictResponse,
-		MediaReferencedResponse,
-		Forbidden,
-		InternalError
-	]
-})).middleware(StudioAuthentication).prefix("/media");
-const StudioConfigurationApi = HttpApiGroup.make("configuration").add(HttpApiEndpoint.get("bootstrap", "/bootstrap", { success: StudioBootstrap })).middleware(StudioAuthentication);
-const StudioSessionApi = HttpApiGroup.make("session").add(HttpApiEndpoint.get("current", "/session", { success: StudioActor })).middleware(StudioAuthentication);
-const InitializationApi = HttpApiGroup.make("initialization").add(HttpApiEndpoint.get("status", "/initialization", {
-	success: InitializationState,
-	error: InternalError
-}), HttpApiEndpoint.post("claim", "/initialization", {
-	payload: InitializationInput,
-	success: User.pipe(HttpApiSchema.status(201)),
-	error: [
-		AlreadyInitialized,
-		InitializationProofRejected,
-		InternalError
-	]
-}));
-const StudioDiagnosticsApi = HttpApiGroup.make("diagnostics").add(HttpApiEndpoint.get("documents", "/diagnostics/documents", {
-	success: Schema.Array(DocumentIssue),
-	error: [Forbidden, InternalError]
-})).middleware(StudioAuthentication);
-const StudioHistoryApi = HttpApiGroup.make("history").add(HttpApiEndpoint.get("list", "/", {
-	query: DocumentHistoryQuery,
-	success: DocumentRevisionPage,
-	error: [
-		InvalidHistoryCursor,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.get("read", "/:documentId/:revisionId", {
-	params: {
-		documentId: DocumentId,
-		revisionId: DocumentRevision.fields.revisionId
-	},
-	success: DocumentRevision,
-	error: [
-		NotFound,
-		Forbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("compare", "/compare", {
-	payload: CompareDocumentRevisionsInput,
-	success: DocumentRevisionComparison,
-	error: [
-		NotFound,
-		HistoryComparisonTooLarge,
-		Forbidden,
-		InternalError
-	]
-})).middleware(StudioAuthentication).prefix("/history");
-const StudioActivityApi = HttpApiGroup.make("activity").add(HttpApiEndpoint.get("list", "/", {
-	query: ActivityQuery,
-	success: ActivityPage,
-	error: [
-		InvalidActivityCursor,
-		Forbidden,
-		InternalError
-	]
-})).middleware(StudioAuthentication).prefix("/activity");
-const StudioUserAdministrationApi = HttpApiGroup.make("users").add(HttpApiEndpoint.get("list", "/", {
-	query: UserQuery,
-	success: UserPage,
-	error: [UserAdministrationForbidden, InternalError]
-}), HttpApiEndpoint.post("create", "/", {
-	payload: CreateUserInput,
-	success: User.pipe(HttpApiSchema.status(201)),
-	error: [
-		UserDuplicate,
-		UserAdministrationForbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("changeRole", "/:userId/role", {
-	params: { userId: User.fields.id },
-	payload: ChangeRolePayload,
-	success: User,
-	error: [
-		MissingUser,
-		UserSelfRoleChange,
-		UserAdministrationForbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.post("revokeSessions", "/:userId/sessions/revoke", {
-	params: { userId: User.fields.id },
-	success: User,
-	error: [
-		MissingUser,
-		UserAdministrationForbidden,
-		InternalError
-	]
-}), HttpApiEndpoint.delete("remove", "/:userId", {
-	params: { userId: User.fields.id },
-	success: User,
-	error: [
-		MissingUser,
-		UserSelfRemoval,
-		UserAdministrationForbidden,
-		InternalError
-	]
-})).middleware(StudioAuthentication).prefix("/users");
-const StudioCollaborationApi = HttpApiGroup.make("collaboration").add(HttpApiEndpoint.post("ticket", "/:documentId/ticket", {
-	params: { documentId: DocumentId },
-	success: CollaborationTicket,
-	error: [
-		NotFound,
-		Forbidden,
-		InternalError
-	]
-})).middleware(StudioAuthentication).prefix("/collaboration");
-var StudioApi = class extends HttpApi.make("StudioApi").add(InitializationApi, PublishedDeliveryApi, StudioConfigurationApi, StudioSessionApi, StudioDiagnosticsApi, PreviewDeliveryApi.middleware(StudioAuthentication), StudioDocumentsApi, StudioHistoryApi, StudioActivityApi, StudioUserAdministrationApi, StudioMediaApi, StudioCollaborationApi).middleware(StudioSchemaError).prefix(STUDIO_API_PATH) {};
-
-//#endregion
-export { ACTIVITY_ACTIONS as A, ActivityTargetKind as B, CollaborationTicket as C, DocumentRevision as D, DocumentHistoryInvalidCursor as E, ActivityEntry as F, DocumentVersionConflict as G, DocumentNotFound as H, ActivityEntryDraft as I, PublishedDocumentNotFound as K, ActivityId as L, ActivityContext as M, ActivityCursor as N, DocumentRevisionComparison as O, ActivityCursorInvalid as P, ActivityPage as R, CollaborationServerMessage as S, DocumentHistoryComparisonTooLarge as T, DocumentPathConflict as U, DocumentMediaUnavailable as V, DocumentValidationFailed as W, UserNotFound as _, StudioBootstrap as a, UserSelfRoleChangeDenied as b, StudioInternalError as c, InitializationProofInvalid as d, InitializationState as f, UserAlreadyExists as g, UserAdministrationDenied as h, StudioBadRequest as i, ActivityAction as j, DocumentRevisionPage as k, studioInternalError as l, User as m, StudioApi as n, StudioRequestConflict as o, CreateUserInput as p, StudioAuthentication as r, StudioSchemaError as s, CurrentStudioRequest as t, InitializationAlreadyCompleted as u, UserPage as v, StateVector as w, CollaborationClientMessage as x, UserSelfRemovalDenied as y, ActivityTarget as z };
-//# sourceMappingURL=StudioHttp-jR2-bc01.js.map