@xeonr/upload-pool-sdk 1.0.0

package/src/index.ts

@@ -0,0 +1,41 @@
+/**
+ * @xeonr/upload-pool-sdk — self-hosted worker SDK for the upl.im content
+ * type pipeline.
+ *
+ * Minimum viable worker:
+ *
+ *   import { createPool } from "@xeonr/upload-pool-sdk";
+ *
+ *   await createPool({
+ *     token: process.env.UPL_POOL_TOKEN!,
+ *     endpoint: process.env.UPL_API_URL!,
+ *     handlers: {
+ *       "my-integration:invoice": async (ctx) => {
+ *         const buf = await ctx.downloadBuffer();
+ *         const thumb = await renderInvoiceThumbnail(buf);
+ *         await ctx.uploadMeta({ type: "THUMBNAIL_LIGHT", data: thumb });
+ *       },
+ *     },
+ *   }).start();
+ */
+import { Pool } from "./pool.js";
+import type { PoolConfig } from "./types.js";
+
+export { Pool } from "./pool.js";
+export { NonRetryableError } from "./errors.js";
+export type {
+	PoolConfig,
+	JobContext,
+	JobHandler,
+	UploadMetaOpts,
+	UploadMetadataPartial,
+	UploadMetadataProto,
+	FolderContext,
+	PoolLifecycleEvents,
+	PresignedUploadRequest,
+	MetaUploadHandle,
+} from "./types.js";
+
+export function createPool(config: PoolConfig): Pool {
+	return new Pool(config);
+}

package/src/job-context.ts

@@ -0,0 +1,244 @@
+/**
+ * JobContext implementation. Wraps the four InternalUploadsService RPCs
+ * + the source download with ergonomic helpers handlers actually want.
+ *
+ * All mutations are scoped to a single upload by the per-job update_token
+ * embedded in the job envelope.
+ */
+import { writeFile } from "node:fs/promises";
+import { create } from "@bufbuild/protobuf";
+import {
+	ConfirmMetaUploadRequestSchema,
+	InternalUpdateUploadRequestSchema,
+	InternalUpdateUploadRequest_AiMetadataSchema,
+	MetaTypeSchema,
+	MetaUploadType,
+	RequestMetaUploadRequestSchema,
+} from "./protocol/uplim/api/v1/uploads_pb.js";
+import { UploadMetadataSchema } from "./protocol/uplim/api/v1/metadata_pb.js";
+import type { RpcClients } from "./rpc-clients.js";
+import type {
+	FolderContext,
+	JobContext,
+	PresignedUploadRequest,
+	UploadMetadataPartial,
+	UploadMetadataProto,
+	UploadMetaOpts,
+} from "./types.js";
+
+const META_TYPE_MAP: Record<UploadMetaOpts["type"], MetaUploadType> = {
+	THUMBNAIL_LIGHT: MetaUploadType.MetaUploadType_THUMBNAIL_LIGHT,
+	THUMBNAIL_DARK: MetaUploadType.MetaUploadType_THUMBNAIL_DARK,
+	VIDEO_TIMELINE: MetaUploadType.MetaUploadType_VIDEO_TIMELINE_N,
+	ARCHIVE_FILE: MetaUploadType.MetaUploadType_ARCHIVE_FILE,
+	IMAGE_COMPAT: MetaUploadType.MetaUploadType_IMAGE_COMPAT,
+	AI_CONTENT: MetaUploadType.MetaUploadType_AI_CONTENT,
+	RENDERER_CONFIG: MetaUploadType.MetaUploadType_RENDERER_CONFIG,
+};
+
+export interface JobEnvelope {
+	jobId: string;
+	uploadId: string;
+	sourceUrl: string;
+	filename: string;
+	mimeType: string;
+	updateToken: string;
+	contentTypeContext: {
+		urn: string;
+		contentTypeId: string;
+		config?: string; // base64-encoded
+	};
+	folderContext?: FolderContext;
+}
+
+export function createJobContext(
+	envelope: JobEnvelope,
+	rpc: RpcClients,
+): JobContext {
+	const ctx: JobContext = {
+		jobId: envelope.jobId,
+		uploadId: envelope.uploadId,
+		filename: envelope.filename,
+		mimeType: envelope.mimeType,
+		contentType: {
+			urn: envelope.contentTypeContext.urn,
+			id: envelope.contentTypeContext.contentTypeId,
+			config: envelope.contentTypeContext.config
+				? Buffer.from(envelope.contentTypeContext.config, "base64")
+				: new Uint8Array(),
+		},
+		folderContext: envelope.folderContext,
+		sourceUrl: envelope.sourceUrl,
+
+		async download() {
+			const resp = await fetch(envelope.sourceUrl);
+			if (!resp.ok || !resp.body) {
+				throw new Error(`source download failed: ${resp.status} ${resp.statusText}`);
+			}
+			return resp.body;
+		},
+
+		async downloadBuffer() {
+			const resp = await fetch(envelope.sourceUrl);
+			if (!resp.ok) {
+				throw new Error(`source download failed: ${resp.status} ${resp.statusText}`);
+			}
+			const buf = await resp.arrayBuffer();
+			return new Uint8Array(buf);
+		},
+
+		async downloadToFile(path: string) {
+			const data = await ctx.downloadBuffer();
+			await writeFile(path, data);
+		},
+
+		async uploadMeta(opts: UploadMetaOpts) {
+			const protoType = META_TYPE_MAP[opts.type];
+			const metaType = create(MetaTypeSchema, {
+				type: protoType,
+				n: opts.instance,
+				filename: opts.filename,
+			});
+
+			// 1. RequestMetaUpload → presigned URL.
+			const requested = await rpc.internalUploads.requestMetaUpload(
+				create(RequestMetaUploadRequestSchema, {
+					updateToken: envelope.updateToken,
+					metaType: [metaType],
+				}),
+			);
+
+			const meta = requested.metaUploads[0];
+			if (!meta) {
+				throw new Error("RequestMetaUpload returned no meta_uploads");
+			}
+
+			// 2. S3 PUT.
+			const contentType = opts.contentType ?? inferContentType(opts.type);
+			const body = opts.data instanceof Uint8Array
+				? opts.data
+				: opts.data;
+			const putResp = await fetch(meta.uploadUrl, {
+				method: "PUT",
+				body: body as BodyInit,
+				headers: { "Content-Type": contentType },
+				duplex: "half",
+			} as RequestInit & { duplex?: "half" });
+			if (!putResp.ok) {
+				throw new Error(`meta upload PUT failed: ${putResp.status} ${putResp.statusText}`);
+			}
+
+			// 3. ConfirmMetaUpload.
+			await rpc.internalUploads.confirmMetaUpload(
+				create(ConfirmMetaUploadRequestSchema, {
+					updateToken: envelope.updateToken,
+					metadataId: [meta.metadataId],
+				}),
+			);
+		},
+
+		async setMetadata(metadata: UploadMetadataPartial | UploadMetadataProto) {
+			// Distinguish a pre-built proto from a partial: protos carry the
+			// @bufbuild/protobuf $typeName brand.
+			const isProto = (metadata as UploadMetadataProto).$typeName !== undefined;
+			let protoMetadata: ReturnType<typeof create<typeof UploadMetadataSchema>>;
+			let thumbnailVersion: number | undefined;
+			if (isProto) {
+				protoMetadata = metadata as ReturnType<typeof create<typeof UploadMetadataSchema>>;
+			} else {
+				const partial = metadata as UploadMetadataPartial;
+				protoMetadata = create(UploadMetadataSchema, {});
+				// Server-side proto has typed sub-messages; the SDK's
+				// UploadMetadataPartial is intentionally loose so workers can
+				// populate just what they computed. Cast into the proto via
+				// the JSON path — fields that don't map are ignored.
+				Object.assign(protoMetadata as object, partial);
+				thumbnailVersion = partial.thumbnailGenerationVersion;
+			}
+
+			await rpc.internalUploads.updateUpload(
+				create(InternalUpdateUploadRequestSchema, {
+					updateToken: envelope.updateToken,
+					metadata: protoMetadata,
+					thumbnailGenerationVersion: thumbnailVersion,
+				}),
+			);
+		},
+
+		async markHasThumbnail(version: number) {
+			await rpc.internalUploads.updateUpload(
+				create(InternalUpdateUploadRequestSchema, {
+					updateToken: envelope.updateToken,
+					hasThumbnail: true,
+					thumbnailGenerationVersion: version,
+				}),
+			);
+		},
+
+		async setDescription(text: string, tags?: string[]) {
+			await rpc.internalUploads.updateUpload(
+				create(InternalUpdateUploadRequestSchema, {
+					updateToken: envelope.updateToken,
+					aiMetadata: create(InternalUpdateUploadRequest_AiMetadataSchema, {
+						description: text,
+						generatedTags: tags ?? [],
+					}),
+				}),
+			);
+		},
+
+		async withPresignedUploads<T>(
+			opts: PresignedUploadRequest[],
+			callback: (handles: import("./types.js").MetaUploadHandle[]) => Promise<T>,
+		): Promise<T> {
+			const metaTypes = opts.map((opt) => create(MetaTypeSchema, {
+				type: META_TYPE_MAP[opt.type],
+				n: opt.instance,
+				filename: opt.filename,
+			}));
+			const requested = await rpc.internalUploads.requestMetaUpload(
+				create(RequestMetaUploadRequestSchema, {
+					updateToken: envelope.updateToken,
+					metaType: metaTypes,
+				}),
+			);
+			if (requested.metaUploads.length !== opts.length) {
+				throw new Error(
+					`RequestMetaUpload returned ${requested.metaUploads.length} URLs, expected ${opts.length}`,
+				);
+			}
+			const handles = requested.metaUploads.map((m) => ({
+				uploadUrl: m.uploadUrl,
+				downloadUrl: m.downloadUrl,
+				metadataId: m.metadataId,
+			}));
+			const result = await callback(handles);
+			// Confirm only after the callback resolves cleanly — on throw,
+			// the rows stay unfinalised and will be cleaned up by the next
+			// confirm sweep or expire naturally.
+			await rpc.internalUploads.confirmMetaUpload(
+				create(ConfirmMetaUploadRequestSchema, {
+					updateToken: envelope.updateToken,
+					metadataId: requested.metaUploads.map((m) => m.metadataId),
+				}),
+			);
+			return result;
+		},
+	};
+
+	return ctx;
+}
+
+function inferContentType(metaType: UploadMetaOpts["type"]): string {
+	switch (metaType) {
+		case "THUMBNAIL_LIGHT":
+		case "THUMBNAIL_DARK":
+		case "VIDEO_TIMELINE":
+		case "IMAGE_COMPAT":
+			return "image/png";
+		case "ARCHIVE_FILE":
+		case "AI_CONTENT":
+		case "RENDERER_CONFIG":
+			return "application/octet-stream";
+	}
+}

package/src/pool.ts

@@ -0,0 +1,143 @@
+/**
+ * Pool: the SDK's top-level lifecycle object. Maintains an SSE connection
+ * to the pool's job stream, dispatches job:dispatch events to the right
+ * handler keyed by content type URN, and orchestrates accept/complete/
+ * report-error against IntegrationQueueService.
+ */
+import { hostname } from "node:os";
+import { randomBytes } from "node:crypto";
+import { create } from "@bufbuild/protobuf";
+import {
+	AcceptJobRequestSchema,
+	CompleteJobRequestSchema,
+	ReportErrorRequestSchema,
+} from "./protocol/uplim/workflow/v1/integration_queue_pb.js";
+import { createRpcClients, type RpcClients } from "./rpc-clients.js";
+import { SseClient } from "./sse-client.js";
+import { createJobContext, type JobEnvelope } from "./job-context.js";
+import { NonRetryableError } from "./errors.js";
+import type {
+	JobContext,
+	JobHandler,
+	PoolConfig,
+} from "./types.js";
+
+export class Pool {
+	private readonly config: PoolConfig;
+	private readonly rpc: RpcClients;
+	private readonly sse: SseClient;
+	private inFlight = 0;
+	private readonly workerId: string;
+	private readonly capabilities: string[];
+
+	constructor(config: PoolConfig) {
+		this.config = {
+			concurrency: 1,
+			onError: defaultErrorHandler,
+			...config,
+		};
+		this.workerId = config.workerId ?? `${hostname()}-${randomBytes(4).toString("hex")}`;
+		this.capabilities = Object.keys(config.handlers);
+		this.rpc = createRpcClients(config.endpoint);
+		this.sse = new SseClient({
+			endpoint: config.endpoint,
+			token: config.token,
+			workerId: this.workerId,
+			capabilities: this.capabilities,
+			onConnected: () => {
+				/* lifecycle: future event emitter hook */
+			},
+			onDisconnected: () => {
+				/* lifecycle: future event emitter hook */
+			},
+			onJobDispatch: (payload) => this.handleDispatch(payload as JobEnvelope),
+		});
+	}
+
+	async start(): Promise<void> {
+		this.sse.start();
+	}
+
+	async stop(): Promise<void> {
+		this.sse.stop();
+	}
+
+	private async handleDispatch(envelope: JobEnvelope): Promise<void> {
+		if (this.inFlight >= (this.config.concurrency ?? 1)) {
+			// Pipeline only dispatches to idle workers (zero in-flight), so
+			// this branch is defensive — if it ever fires we silently
+			// drop the dispatch and let the pipeline timeout requeue.
+			return;
+		}
+		this.inFlight++;
+
+		const handler = this.resolveHandler(envelope.contentTypeContext.urn);
+		const ctx = createJobContext(envelope, this.rpc);
+
+		try {
+			// AcceptJob — clears the pipeline's accept-timeout.
+			await this.rpc.integrationQueue.acceptJob(
+				create(AcceptJobRequestSchema, {
+					jobId: envelope.jobId,
+					workerId: this.workerId,
+					queueToken: this.config.token,
+				}),
+			);
+
+			if (!handler) {
+				await this.reportError(
+					envelope.jobId,
+					ctx,
+					new NonRetryableError(`no handler for URN ${envelope.contentTypeContext.urn}`),
+				);
+				return;
+			}
+
+			await handler(ctx);
+
+			await this.rpc.integrationQueue.completeJob(
+				create(CompleteJobRequestSchema, {
+					jobId: envelope.jobId,
+					workerId: this.workerId,
+					queueToken: this.config.token,
+				}),
+			);
+		} catch (err) {
+			await this.reportError(envelope.jobId, ctx, err as Error);
+		} finally {
+			this.inFlight--;
+		}
+	}
+
+	private resolveHandler(urn: string): JobHandler | undefined {
+		return this.config.handlers[urn] ?? this.config.onUnhandled;
+	}
+
+	private async reportError(
+		jobId: string,
+		ctx: JobContext,
+		err: Error,
+	): Promise<void> {
+		const retry = !(err instanceof NonRetryableError);
+		this.config.onError?.(err, ctx);
+		try {
+			await this.rpc.integrationQueue.reportError(
+				create(ReportErrorRequestSchema, {
+					jobId,
+					workerId: this.workerId,
+					queueToken: this.config.token,
+					error: err.message,
+					retry,
+				}),
+			);
+		} catch (rptErr) {
+			this.config.onError?.(rptErr as Error, ctx);
+		}
+	}
+}
+
+function defaultErrorHandler(err: Error, ctx?: JobContext): void {
+	const where = ctx ? `job ${ctx.jobId} (${ctx.contentType.urn})` : "pool";
+	// eslint-disable-next-line no-console
+	console.error(`[@xeonr/upload-pool-sdk] ${where}: ${err.message}`);
+}

package/src/protocol/buf/validate/expression_pb.ts

@@ -0,0 +1,163 @@
+// Copyright 2023 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// @generated by protoc-gen-es v2.10.1 with parameter "target=ts,import_extension=.js"
+// @generated from file buf/validate/expression.proto (package buf.validate, syntax proto3)
+/* eslint-disable */
+
+import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
+import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2";
+import type { Message } from "@bufbuild/protobuf";
+
+/**
+ * Describes the file buf/validate/expression.proto.
+ */
+export const file_buf_validate_expression: GenFile = /*@__PURE__*/
+  fileDesc("Ch1idWYvdmFsaWRhdGUvZXhwcmVzc2lvbi5wcm90bxIMYnVmLnZhbGlkYXRlIj0KCkNvbnN0cmFpbnQSCgoCaWQYASABKAkSDwoHbWVzc2FnZRgCIAEoCRISCgpleHByZXNzaW9uGAMgASgJIjkKClZpb2xhdGlvbnMSKwoKdmlvbGF0aW9ucxgBIAMoCzIXLmJ1Zi52YWxpZGF0ZS5WaW9sYXRpb24iWAoJVmlvbGF0aW9uEhIKCmZpZWxkX3BhdGgYASABKAkSFQoNY29uc3RyYWludF9pZBgCIAEoCRIPCgdtZXNzYWdlGAMgASgJEg8KB2Zvcl9rZXkYBCABKAhCvQEKEGNvbS5idWYudmFsaWRhdGVCD0V4cHJlc3Npb25Qcm90b1ABWkdidWYuYnVpbGQvZ2VuL2dvL2J1ZmJ1aWxkL3Byb3RvdmFsaWRhdGUvcHJvdG9jb2xidWZmZXJzL2dvL2J1Zi92YWxpZGF0ZaICA0JWWKoCDEJ1Zi5WYWxpZGF0ZcoCDEJ1ZlxWYWxpZGF0ZeICGEJ1ZlxWYWxpZGF0ZVxHUEJNZXRhZGF0YeoCDUJ1Zjo6VmFsaWRhdGViBnByb3RvMw");
+
+/**
+ * `Constraint` represents a validation rule written in the Common Expression
+ * Language (CEL) syntax. Each Constraint includes a unique identifier, an
+ * optional error message, and the CEL expression to evaluate. For more
+ * information on CEL, [see our documentation](https://github.com/bufbuild/protovalidate/blob/main/docs/cel.md).
+ *
+ * ```proto
+ * message Foo {
+ *   option (buf.validate.message).cel = {
+ *     id: "foo.bar"
+ *     message: "bar must be greater than 0"
+ *     expression: "this.bar > 0"
+ *   };
+ *   int32 bar = 1;
+ * }
+ * ```
+ *
+ * @generated from message buf.validate.Constraint
+ */
+export type Constraint = Message<"buf.validate.Constraint"> & {
+  /**
+   * `id` is a string that serves as a machine-readable name for this Constraint.
+   * It should be unique within its scope, which could be either a message or a field.
+   *
+   * @generated from field: string id = 1;
+   */
+  id: string;
+
+  /**
+   * `message` is an optional field that provides a human-readable error message
+   * for this Constraint when the CEL expression evaluates to false. If a
+   * non-empty message is provided, any strings resulting from the CEL
+   * expression evaluation are ignored.
+   *
+   * @generated from field: string message = 2;
+   */
+  message: string;
+
+  /**
+   * `expression` is the actual CEL expression that will be evaluated for
+   * validation. This string must resolve to either a boolean or a string
+   * value. If the expression evaluates to false or a non-empty string, the
+   * validation is considered failed, and the message is rejected.
+   *
+   * @generated from field: string expression = 3;
+   */
+  expression: string;
+};
+
+/**
+ * Describes the message buf.validate.Constraint.
+ * Use `create(ConstraintSchema)` to create a new message.
+ */
+export const ConstraintSchema: GenMessage<Constraint> = /*@__PURE__*/
+  messageDesc(file_buf_validate_expression, 0);
+
+/**
+ * `Violations` is a collection of `Violation` messages. This message type is returned by
+ * protovalidate when a proto message fails to meet the requirements set by the `Constraint` validation rules.
+ * Each individual violation is represented by a `Violation` message.
+ *
+ * @generated from message buf.validate.Violations
+ */
+export type Violations = Message<"buf.validate.Violations"> & {
+  /**
+   * `violations` is a repeated field that contains all the `Violation` messages corresponding to the violations detected.
+   *
+   * @generated from field: repeated buf.validate.Violation violations = 1;
+   */
+  violations: Violation[];
+};
+
+/**
+ * Describes the message buf.validate.Violations.
+ * Use `create(ViolationsSchema)` to create a new message.
+ */
+export const ViolationsSchema: GenMessage<Violations> = /*@__PURE__*/
+  messageDesc(file_buf_validate_expression, 1);
+
+/**
+ * `Violation` represents a single instance where a validation rule, expressed
+ * as a `Constraint`, was not met. It provides information about the field that
+ * caused the violation, the specific constraint that wasn't fulfilled, and a
+ * human-readable error message.
+ *
+ * ```json
+ * {
+ *   "fieldPath": "bar",
+ *   "constraintId": "foo.bar",
+ *   "message": "bar must be greater than 0"
+ * }
+ * ```
+ *
+ * @generated from message buf.validate.Violation
+ */
+export type Violation = Message<"buf.validate.Violation"> & {
+  /**
+   * `field_path` is a machine-readable identifier that points to the specific field that failed the validation.
+   * This could be a nested field, in which case the path will include all the parent fields leading to the actual field that caused the violation.
+   *
+   * @generated from field: string field_path = 1;
+   */
+  fieldPath: string;
+
+  /**
+   * `constraint_id` is the unique identifier of the `Constraint` that was not fulfilled.
+   * This is the same `id` that was specified in the `Constraint` message, allowing easy tracing of which rule was violated.
+   *
+   * @generated from field: string constraint_id = 2;
+   */
+  constraintId: string;
+
+  /**
+   * `message` is a human-readable error message that describes the nature of the violation.
+   * This can be the default error message from the violated `Constraint`, or it can be a custom message that gives more context about the violation.
+   *
+   * @generated from field: string message = 3;
+   */
+  message: string;
+
+  /**
+   * `for_key` indicates whether the violation was caused by a map key, rather than a value.
+   *
+   * @generated from field: bool for_key = 4;
+   */
+  forKey: boolean;
+};
+
+/**
+ * Describes the message buf.validate.Violation.
+ * Use `create(ViolationSchema)` to create a new message.
+ */
+export const ViolationSchema: GenMessage<Violation> = /*@__PURE__*/
+  messageDesc(file_buf_validate_expression, 2);
+

package/src/protocol/buf/validate/priv/private_pb.ts

@@ -0,0 +1,86 @@
+// Copyright 2023 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// @generated by protoc-gen-es v2.10.1 with parameter "target=ts,import_extension=.js"
+// @generated from file buf/validate/priv/private.proto (package buf.validate.priv, syntax proto3)
+/* eslint-disable */
+
+import type { GenExtension, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
+import { extDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2";
+import type { FieldOptions } from "@bufbuild/protobuf/wkt";
+import { file_google_protobuf_descriptor } from "@bufbuild/protobuf/wkt";
+import type { Message } from "@bufbuild/protobuf";
+
+/**
+ * Describes the file buf/validate/priv/private.proto.
+ */
+export const file_buf_validate_priv_private: GenFile = /*@__PURE__*/
+  fileDesc("Ch9idWYvdmFsaWRhdGUvcHJpdi9wcml2YXRlLnByb3RvEhFidWYudmFsaWRhdGUucHJpdiI+ChBGaWVsZENvbnN0cmFpbnRzEioKA2NlbBgBIAMoCzIdLmJ1Zi52YWxpZGF0ZS5wcml2LkNvbnN0cmFpbnQiPQoKQ29uc3RyYWludBIKCgJpZBgBIAEoCRIPCgdtZXNzYWdlGAIgASgJEhIKCmV4cHJlc3Npb24YAyABKAk6XAoFZmllbGQSHS5nb29nbGUucHJvdG9idWYuRmllbGRPcHRpb25zGIgJIAEoCzIjLmJ1Zi52YWxpZGF0ZS5wcml2LkZpZWxkQ29uc3RyYWludHNSBWZpZWxkiAEBQtkBChVjb20uYnVmLnZhbGlkYXRlLnByaXZCDFByaXZhdGVQcm90b1ABWkxidWYuYnVpbGQvZ2VuL2dvL2J1ZmJ1aWxkL3Byb3RvdmFsaWRhdGUvcHJvdG9jb2xidWZmZXJzL2dvL2J1Zi92YWxpZGF0ZS9wcml2ogIDQlZQqgIRQnVmLlZhbGlkYXRlLlByaXbKAhFCdWZcVmFsaWRhdGVcUHJpduICHUJ1ZlxWYWxpZGF0ZVxQcml2XEdQQk1ldGFkYXRh6gITQnVmOjpWYWxpZGF0ZTo6UHJpdmIGcHJvdG8z", [file_google_protobuf_descriptor]);
+
+/**
+ * Do not use. Internal to protovalidate library
+ *
+ * @generated from message buf.validate.priv.FieldConstraints
+ */
+export type FieldConstraints = Message<"buf.validate.priv.FieldConstraints"> & {
+  /**
+   * @generated from field: repeated buf.validate.priv.Constraint cel = 1;
+   */
+  cel: Constraint[];
+};
+
+/**
+ * Describes the message buf.validate.priv.FieldConstraints.
+ * Use `create(FieldConstraintsSchema)` to create a new message.
+ */
+export const FieldConstraintsSchema: GenMessage<FieldConstraints> = /*@__PURE__*/
+  messageDesc(file_buf_validate_priv_private, 0);
+
+/**
+ * Do not use. Internal to protovalidate library
+ *
+ * @generated from message buf.validate.priv.Constraint
+ */
+export type Constraint = Message<"buf.validate.priv.Constraint"> & {
+  /**
+   * @generated from field: string id = 1;
+   */
+  id: string;
+
+  /**
+   * @generated from field: string message = 2;
+   */
+  message: string;
+
+  /**
+   * @generated from field: string expression = 3;
+   */
+  expression: string;
+};
+
+/**
+ * Describes the message buf.validate.priv.Constraint.
+ * Use `create(ConstraintSchema)` to create a new message.
+ */
+export const ConstraintSchema: GenMessage<Constraint> = /*@__PURE__*/
+  messageDesc(file_buf_validate_priv_private, 1);
+
+/**
+ * Do not use. Internal to protovalidate library
+ *
+ * @generated from extension: optional buf.validate.priv.FieldConstraints field = 1160;
+ */
+export const field: GenExtension<FieldOptions, FieldConstraints> = /*@__PURE__*/
+  extDesc(file_buf_validate_priv_private, 0);
+