diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/index.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..8594f41be8ce609fc3849607785f5038fad3dcd3 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/index.ts @@ -0,0 +1,23 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +export { Anthropic as default } from './client'; + +export { type Uploadable, toFile } from './core/uploads'; +export { APIPromise } from './core/api-promise'; +export { BaseAnthropic, Anthropic, type ClientOptions, HUMAN_PROMPT, AI_PROMPT } from './client'; +export { PagePromise } from './core/pagination'; +export { + AnthropicError, + APIError, + APIConnectionError, + APIConnectionTimeoutError, + APIUserAbortError, + NotFoundError, + ConflictError, + RateLimitError, + BadRequestError, + AuthenticationError, + InternalServerError, + PermissionDeniedError, + UnprocessableEntityError, +} from './core/error'; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/README.md b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3ef5a25bac10eec3925c29eacbfa68a84517c726 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/README.md @@ -0,0 +1,3 @@ +# `internal` + +The modules in this directory are not importable outside this package and will change between releases. diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/builtin-types.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/builtin-types.ts new file mode 100644 index 0000000000000000000000000000000000000000..c23d3bdedc13683a2ad7defc1515539ae2f1b32e --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/builtin-types.ts @@ -0,0 +1,93 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +export type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise; + +/** + * An alias to the builtin `RequestInit` type so we can + * easily alias it in import statements if there are name clashes. + * + * https://developer.mozilla.org/docs/Web/API/RequestInit + */ +type _RequestInit = RequestInit; + +/** + * An alias to the builtin `Response` type so we can + * easily alias it in import statements if there are name clashes. + * + * https://developer.mozilla.org/docs/Web/API/Response + */ +type _Response = Response; + +/** + * The type for the first argument to `fetch`. + * + * https://developer.mozilla.org/docs/Web/API/Window/fetch#resource + */ +type _RequestInfo = Request | URL | string; + +/** + * The type for constructing `RequestInit` Headers. + * + * https://developer.mozilla.org/docs/Web/API/RequestInit#setting_headers + */ +type _HeadersInit = RequestInit['headers']; + +/** + * The type for constructing `RequestInit` body. + * + * https://developer.mozilla.org/docs/Web/API/RequestInit#body + */ +type _BodyInit = RequestInit['body']; + +/** + * An alias to the builtin `Array` type so we can + * easily alias it in import statements if there are name clashes. + */ +type _Array = Array; + +/** + * An alias to the builtin `Record` type so we can + * easily alias it in import statements if there are name clashes. + */ +type _Record = Record; + +export type { + _Array as Array, + _BodyInit as BodyInit, + _HeadersInit as HeadersInit, + _Record as Record, + _RequestInfo as RequestInfo, + _RequestInit as RequestInit, + _Response as Response, +}; + +/** + * A copy of the builtin `EndingType` type as it isn't fully supported in certain + * environments and attempting to reference the global version will error. + * + * https://github.com/microsoft/TypeScript/blob/49ad1a3917a0ea57f5ff248159256e12bb1cb705/src/lib/dom.generated.d.ts#L27941 + */ +type EndingType = 'native' | 'transparent'; + +/** + * A copy of the builtin `BlobPropertyBag` type as it isn't fully supported in certain + * environments and attempting to reference the global version will error. + * + * https://github.com/microsoft/TypeScript/blob/49ad1a3917a0ea57f5ff248159256e12bb1cb705/src/lib/dom.generated.d.ts#L154 + * https://developer.mozilla.org/en-US/docs/Web/API/Blob/Blob#options + */ +export interface BlobPropertyBag { + endings?: EndingType; + type?: string; +} + +/** + * A copy of the builtin `FilePropertyBag` type as it isn't fully supported in certain + * environments and attempting to reference the global version will error. + * + * https://github.com/microsoft/TypeScript/blob/49ad1a3917a0ea57f5ff248159256e12bb1cb705/src/lib/dom.generated.d.ts#L503 + * https://developer.mozilla.org/en-US/docs/Web/API/File/File#options + */ +export interface FilePropertyBag extends BlobPropertyBag { + lastModified?: number; +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/constants.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/constants.ts new file mode 100644 index 0000000000000000000000000000000000000000..14e9109531a9bf4cb89f6e531858f6a0cb98faea --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/constants.ts @@ -0,0 +1,12 @@ +// File containing shared constants + +/** + * Model-specific timeout constraints for non-streaming requests + */ +export const MODEL_NONSTREAMING_TOKENS: Record = { + 'claude-opus-4-20250514': 8192, + 'claude-opus-4-0': 8192, + 'claude-4-opus-20250514': 8192, + 'anthropic.claude-opus-4-20250514-v1:0': 8192, + 'claude-opus-4@20250514': 8192, +}; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/decoders/jsonl.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/decoders/jsonl.ts new file mode 100644 index 0000000000000000000000000000000000000000..ba0cb8f4ad2ace42a4e6bbeaaaf84b1fb5422f6f --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/decoders/jsonl.ts @@ -0,0 +1,48 @@ +import { AnthropicError } from '../../core/error'; +import { ReadableStreamToAsyncIterable } from '../shims'; +import { LineDecoder, type Bytes } from './line'; + +export class JSONLDecoder { + controller: AbortController; + + constructor( + private iterator: AsyncIterableIterator, + controller: AbortController, + ) { + this.controller = controller; + } + + private async *decoder(): AsyncIterator { + const lineDecoder = new LineDecoder(); + for await (const chunk of this.iterator) { + for (const line of lineDecoder.decode(chunk)) { + yield JSON.parse(line); + } + } + + for (const line of lineDecoder.flush()) { + yield JSON.parse(line); + } + } + + [Symbol.asyncIterator](): AsyncIterator { + return this.decoder(); + } + + static fromResponse(response: Response, controller: AbortController): JSONLDecoder { + if (!response.body) { + controller.abort(); + if ( + typeof (globalThis as any).navigator !== 'undefined' && + (globalThis as any).navigator.product === 'ReactNative' + ) { + throw new AnthropicError( + `The default react-native fetch implementation does not support streaming. Please use expo/fetch: https://docs.expo.dev/versions/latest/sdk/expo/#expofetch-api`, + ); + } + throw new AnthropicError(`Attempted to iterate over a response with no body`); + } + + return new JSONLDecoder(ReadableStreamToAsyncIterable(response.body), controller); + } +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/decoders/line.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/decoders/line.ts new file mode 100644 index 0000000000000000000000000000000000000000..b3bfa97cdfd4723a61c56281af4818dbeedafa22 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/decoders/line.ts @@ -0,0 +1,135 @@ +import { concatBytes, decodeUTF8, encodeUTF8 } from '../utils/bytes'; + +export type Bytes = string | ArrayBuffer | Uint8Array | null | undefined; + +/** + * A re-implementation of httpx's `LineDecoder` in Python that handles incrementally + * reading lines from text. + * + * https://github.com/encode/httpx/blob/920333ea98118e9cf617f246905d7b202510941c/httpx/_decoders.py#L258 + */ +export class LineDecoder { + // prettier-ignore + static NEWLINE_CHARS = new Set(['\n', '\r']); + static NEWLINE_REGEXP = /\r\n|[\n\r]/g; + + #buffer: Uint8Array; + #carriageReturnIndex: number | null; + + constructor() { + this.#buffer = new Uint8Array(); + this.#carriageReturnIndex = null; + } + + decode(chunk: Bytes): string[] { + if (chunk == null) { + return []; + } + + const binaryChunk = + chunk instanceof ArrayBuffer ? new Uint8Array(chunk) + : typeof chunk === 'string' ? encodeUTF8(chunk) + : chunk; + + this.#buffer = concatBytes([this.#buffer, binaryChunk]); + + const lines: string[] = []; + let patternIndex; + while ((patternIndex = findNewlineIndex(this.#buffer, this.#carriageReturnIndex)) != null) { + if (patternIndex.carriage && this.#carriageReturnIndex == null) { + // skip until we either get a corresponding `\n`, a new `\r` or nothing + this.#carriageReturnIndex = patternIndex.index; + continue; + } + + // we got double \r or \rtext\n + if ( + this.#carriageReturnIndex != null && + (patternIndex.index !== this.#carriageReturnIndex + 1 || patternIndex.carriage) + ) { + lines.push(decodeUTF8(this.#buffer.subarray(0, this.#carriageReturnIndex - 1))); + this.#buffer = this.#buffer.subarray(this.#carriageReturnIndex); + this.#carriageReturnIndex = null; + continue; + } + + const endIndex = + this.#carriageReturnIndex !== null ? patternIndex.preceding - 1 : patternIndex.preceding; + + const line = decodeUTF8(this.#buffer.subarray(0, endIndex)); + lines.push(line); + + this.#buffer = this.#buffer.subarray(patternIndex.index); + this.#carriageReturnIndex = null; + } + + return lines; + } + + flush(): string[] { + if (!this.#buffer.length) { + return []; + } + return this.decode('\n'); + } +} + +/** + * This function searches the buffer for the end patterns, (\r or \n) + * and returns an object with the index preceding the matched newline and the + * index after the newline char. `null` is returned if no new line is found. + * + * ```ts + * findNewLineIndex('abc\ndef') -> { preceding: 2, index: 3 } + * ``` + */ +function findNewlineIndex( + buffer: Uint8Array, + startIndex: number | null, +): { preceding: number; index: number; carriage: boolean } | null { + const newline = 0x0a; // \n + const carriage = 0x0d; // \r + + for (let i = startIndex ?? 0; i < buffer.length; i++) { + if (buffer[i] === newline) { + return { preceding: i, index: i + 1, carriage: false }; + } + + if (buffer[i] === carriage) { + return { preceding: i, index: i + 1, carriage: true }; + } + } + + return null; +} + +export function findDoubleNewlineIndex(buffer: Uint8Array): number { + // This function searches the buffer for the end patterns (\r\r, \n\n, \r\n\r\n) + // and returns the index right after the first occurrence of any pattern, + // or -1 if none of the patterns are found. + const newline = 0x0a; // \n + const carriage = 0x0d; // \r + + for (let i = 0; i < buffer.length - 1; i++) { + if (buffer[i] === newline && buffer[i + 1] === newline) { + // \n\n + return i + 2; + } + if (buffer[i] === carriage && buffer[i + 1] === carriage) { + // \r\r + return i + 2; + } + if ( + buffer[i] === carriage && + buffer[i + 1] === newline && + i + 3 < buffer.length && + buffer[i + 2] === carriage && + buffer[i + 3] === newline + ) { + // \r\n\r\n + return i + 4; + } + } + + return -1; +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/detect-platform.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/detect-platform.ts new file mode 100644 index 0000000000000000000000000000000000000000..e82d95c92f05cdc6a167aea50becedff88116adc --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/detect-platform.ts @@ -0,0 +1,196 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import { VERSION } from '../version'; + +export const isRunningInBrowser = () => { + return ( + // @ts-ignore + typeof window !== 'undefined' && + // @ts-ignore + typeof window.document !== 'undefined' && + // @ts-ignore + typeof navigator !== 'undefined' + ); +}; + +type DetectedPlatform = 'deno' | 'node' | 'edge' | 'unknown'; + +/** + * Note this does not detect 'browser'; for that, use getBrowserInfo(). + */ +function getDetectedPlatform(): DetectedPlatform { + if (typeof Deno !== 'undefined' && Deno.build != null) { + return 'deno'; + } + if (typeof EdgeRuntime !== 'undefined') { + return 'edge'; + } + if ( + Object.prototype.toString.call( + typeof (globalThis as any).process !== 'undefined' ? (globalThis as any).process : 0, + ) === '[object process]' + ) { + return 'node'; + } + return 'unknown'; +} + +declare const Deno: any; +declare const EdgeRuntime: any; +type Arch = 'x32' | 'x64' | 'arm' | 'arm64' | `other:${string}` | 'unknown'; +type PlatformName = + | 'MacOS' + | 'Linux' + | 'Windows' + | 'FreeBSD' + | 'OpenBSD' + | 'iOS' + | 'Android' + | `Other:${string}` + | 'Unknown'; +type Browser = 'ie' | 'edge' | 'chrome' | 'firefox' | 'safari'; +type PlatformProperties = { + 'X-Stainless-Lang': 'js'; + 'X-Stainless-Package-Version': string; + 'X-Stainless-OS': PlatformName; + 'X-Stainless-Arch': Arch; + 'X-Stainless-Runtime': 'node' | 'deno' | 'edge' | `browser:${Browser}` | 'unknown'; + 'X-Stainless-Runtime-Version': string; +}; +const getPlatformProperties = (): PlatformProperties => { + const detectedPlatform = getDetectedPlatform(); + if (detectedPlatform === 'deno') { + return { + 'X-Stainless-Lang': 'js', + 'X-Stainless-Package-Version': VERSION, + 'X-Stainless-OS': normalizePlatform(Deno.build.os), + 'X-Stainless-Arch': normalizeArch(Deno.build.arch), + 'X-Stainless-Runtime': 'deno', + 'X-Stainless-Runtime-Version': + typeof Deno.version === 'string' ? Deno.version : Deno.version?.deno ?? 'unknown', + }; + } + if (typeof EdgeRuntime !== 'undefined') { + return { + 'X-Stainless-Lang': 'js', + 'X-Stainless-Package-Version': VERSION, + 'X-Stainless-OS': 'Unknown', + 'X-Stainless-Arch': `other:${EdgeRuntime}`, + 'X-Stainless-Runtime': 'edge', + 'X-Stainless-Runtime-Version': (globalThis as any).process.version, + }; + } + // Check if Node.js + if (detectedPlatform === 'node') { + return { + 'X-Stainless-Lang': 'js', + 'X-Stainless-Package-Version': VERSION, + 'X-Stainless-OS': normalizePlatform((globalThis as any).process.platform ?? 'unknown'), + 'X-Stainless-Arch': normalizeArch((globalThis as any).process.arch ?? 'unknown'), + 'X-Stainless-Runtime': 'node', + 'X-Stainless-Runtime-Version': (globalThis as any).process.version ?? 'unknown', + }; + } + + const browserInfo = getBrowserInfo(); + if (browserInfo) { + return { + 'X-Stainless-Lang': 'js', + 'X-Stainless-Package-Version': VERSION, + 'X-Stainless-OS': 'Unknown', + 'X-Stainless-Arch': 'unknown', + 'X-Stainless-Runtime': `browser:${browserInfo.browser}`, + 'X-Stainless-Runtime-Version': browserInfo.version, + }; + } + + // TODO add support for Cloudflare workers, etc. + return { + 'X-Stainless-Lang': 'js', + 'X-Stainless-Package-Version': VERSION, + 'X-Stainless-OS': 'Unknown', + 'X-Stainless-Arch': 'unknown', + 'X-Stainless-Runtime': 'unknown', + 'X-Stainless-Runtime-Version': 'unknown', + }; +}; + +type BrowserInfo = { + browser: Browser; + version: string; +}; + +declare const navigator: { userAgent: string } | undefined; + +// Note: modified from https://github.com/JS-DevTools/host-environment/blob/b1ab79ecde37db5d6e163c050e54fe7d287d7c92/src/isomorphic.browser.ts +function getBrowserInfo(): BrowserInfo | null { + if (typeof navigator === 'undefined' || !navigator) { + return null; + } + + // NOTE: The order matters here! + const browserPatterns = [ + { key: 'edge' as const, pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: 'ie' as const, pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: 'ie' as const, pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: 'chrome' as const, pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: 'firefox' as const, pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ }, + { key: 'safari' as const, pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ }, + ]; + + // Find the FIRST matching browser + for (const { key, pattern } of browserPatterns) { + const match = pattern.exec(navigator.userAgent); + if (match) { + const major = match[1] || 0; + const minor = match[2] || 0; + const patch = match[3] || 0; + + return { browser: key, version: `${major}.${minor}.${patch}` }; + } + } + + return null; +} + +const normalizeArch = (arch: string): Arch => { + // Node docs: + // - https://nodejs.org/api/process.html#processarch + // Deno docs: + // - https://doc.deno.land/deno/stable/~/Deno.build + if (arch === 'x32') return 'x32'; + if (arch === 'x86_64' || arch === 'x64') return 'x64'; + if (arch === 'arm') return 'arm'; + if (arch === 'aarch64' || arch === 'arm64') return 'arm64'; + if (arch) return `other:${arch}`; + return 'unknown'; +}; + +const normalizePlatform = (platform: string): PlatformName => { + // Node platforms: + // - https://nodejs.org/api/process.html#processplatform + // Deno platforms: + // - https://doc.deno.land/deno/stable/~/Deno.build + // - https://github.com/denoland/deno/issues/14799 + + platform = platform.toLowerCase(); + + // NOTE: this iOS check is untested and may not work + // Node does not work natively on IOS, there is a fork at + // https://github.com/nodejs-mobile/nodejs-mobile + // however it is unknown at the time of writing how to detect if it is running + if (platform.includes('ios')) return 'iOS'; + if (platform === 'android') return 'Android'; + if (platform === 'darwin') return 'MacOS'; + if (platform === 'win32') return 'Windows'; + if (platform === 'freebsd') return 'FreeBSD'; + if (platform === 'openbsd') return 'OpenBSD'; + if (platform === 'linux') return 'Linux'; + if (platform) return `Other:${platform}`; + return 'Unknown'; +}; + +let _platformHeaders: PlatformProperties; +export const getPlatformHeaders = () => { + return (_platformHeaders ??= getPlatformProperties()); +}; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/errors.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/errors.ts new file mode 100644 index 0000000000000000000000000000000000000000..82c7b14d577cccf53e1719ea34c11d47351c5a63 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/errors.ts @@ -0,0 +1,33 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +export function isAbortError(err: unknown) { + return ( + typeof err === 'object' && + err !== null && + // Spec-compliant fetch implementations + (('name' in err && (err as any).name === 'AbortError') || + // Expo fetch + ('message' in err && String((err as any).message).includes('FetchRequestCanceledException'))) + ); +} + +export const castToError = (err: any): Error => { + if (err instanceof Error) return err; + if (typeof err === 'object' && err !== null) { + try { + if (Object.prototype.toString.call(err) === '[object Error]') { + // @ts-ignore - not all envs have native support for cause yet + const error = new Error(err.message, err.cause ? { cause: err.cause } : {}); + if (err.stack) error.stack = err.stack; + // @ts-ignore - not all envs have native support for cause yet + if (err.cause && !error.cause) error.cause = err.cause; + if (err.name) error.name = err.name; + return error; + } + } catch {} + try { + return new Error(JSON.stringify(err)); + } catch {} + } + return new Error(err); +}; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/headers.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/headers.ts new file mode 100644 index 0000000000000000000000000000000000000000..566b38687da2954c2e176fd2538ed7f7dfb32f73 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/headers.ts @@ -0,0 +1,99 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import { isReadonlyArray } from './utils/values'; + +type HeaderValue = string | undefined | null; +export type HeadersLike = + | Headers + | readonly HeaderValue[][] + | Record + | undefined + | null + | NullableHeaders; + +const brand_privateNullableHeaders = Symbol.for('brand.privateNullableHeaders') as symbol & { + description: 'brand.privateNullableHeaders'; +}; + +/** + * @internal + * Users can pass explicit nulls to unset default headers. When we parse them + * into a standard headers type we need to preserve that information. + */ +export type NullableHeaders = { + /** Brand check, prevent users from creating a NullableHeaders. */ + [_: typeof brand_privateNullableHeaders]: true; + /** Parsed headers. */ + values: Headers; + /** Set of lowercase header names explicitly set to null. */ + nulls: Set; +}; + +function* iterateHeaders(headers: HeadersLike): IterableIterator { + if (!headers) return; + + if (brand_privateNullableHeaders in headers) { + const { values, nulls } = headers as NullableHeaders; + yield* values.entries(); + for (const name of nulls) { + yield [name, null]; + } + return; + } + + let shouldClear = false; + let iter: Iterable; + if (headers instanceof Headers) { + iter = headers.entries(); + } else if (isReadonlyArray(headers)) { + iter = headers; + } else { + shouldClear = true; + iter = Object.entries(headers ?? {}); + } + for (let row of iter) { + const name = row[0]; + if (typeof name !== 'string') throw new TypeError('expected header name to be a string'); + const values = isReadonlyArray(row[1]) ? row[1] : [row[1]]; + let didClear = false; + for (const value of values) { + if (value === undefined) continue; + + // Objects keys always overwrite older headers, they never append. + // Yield a null to clear the header before adding the new values. + if (shouldClear && !didClear) { + didClear = true; + yield [name, null]; + } + yield [name, value]; + } + } +} + +export const buildHeaders = (newHeaders: HeadersLike[]): NullableHeaders => { + const targetHeaders = new Headers(); + const nullHeaders = new Set(); + for (const headers of newHeaders) { + const seenHeaders = new Set(); + for (const [name, value] of iterateHeaders(headers)) { + const lowerName = name.toLowerCase(); + if (!seenHeaders.has(lowerName)) { + targetHeaders.delete(name); + seenHeaders.add(lowerName); + } + if (value === null) { + targetHeaders.delete(name); + nullHeaders.add(lowerName); + } else { + targetHeaders.append(name, value); + nullHeaders.delete(lowerName); + } + } + } + return { [brand_privateNullableHeaders]: true, values: targetHeaders, nulls: nullHeaders }; +}; + +export const isEmptyHeaders = (headers: HeadersLike) => { + for (const _ of iterateHeaders(headers)) return false; + return true; +}; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/parse.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/parse.ts new file mode 100644 index 0000000000000000000000000000000000000000..f5b8e52702b62f8e0e755b9288daa9474f979a63 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/parse.ts @@ -0,0 +1,84 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import type { FinalRequestOptions } from './request-options'; +import { Stream } from '../core/streaming'; +import { type BaseAnthropic } from '../client'; +import { formatRequestDetails, loggerFor } from './utils/log'; +import type { AbstractPage } from '../core/pagination'; + +export type APIResponseProps = { + response: Response; + options: FinalRequestOptions; + controller: AbortController; + requestLogID: string; + retryOfRequestLogID: string | undefined; + startTime: number; +}; + +export async function defaultParseResponse( + client: BaseAnthropic, + props: APIResponseProps, +): Promise> { + const { response, requestLogID, retryOfRequestLogID, startTime } = props; + const body = await (async () => { + if (props.options.stream) { + loggerFor(client).debug('response', response.status, response.url, response.headers, response.body); + + // Note: there is an invariant here that isn't represented in the type system + // that if you set `stream: true` the response type must also be `Stream` + + if (props.options.__streamClass) { + return props.options.__streamClass.fromSSEResponse(response, props.controller) as any; + } + + return Stream.fromSSEResponse(response, props.controller) as any; + } + + // fetch refuses to read the body when the status code is 204. + if (response.status === 204) { + return null as T; + } + + if (props.options.__binaryResponse) { + return response as unknown as T; + } + + const contentType = response.headers.get('content-type'); + const mediaType = contentType?.split(';')[0]?.trim(); + const isJSON = mediaType?.includes('application/json') || mediaType?.endsWith('+json'); + if (isJSON) { + const json = await response.json(); + return addRequestID(json as T, response); + } + + const text = await response.text(); + return text as unknown as T; + })(); + loggerFor(client).debug( + `[${requestLogID}] response parsed`, + formatRequestDetails({ + retryOfRequestLogID, + url: response.url, + status: response.status, + body, + durationMs: Date.now() - startTime, + }), + ); + return body; +} + +export type WithRequestID = + T extends Array | Response | AbstractPage ? T + : T extends Record ? T & { _request_id?: string | null } + : T; + +export function addRequestID(value: T, response: Response): WithRequestID { + if (!value || typeof value !== 'object' || Array.isArray(value)) { + return value as WithRequestID; + } + + return Object.defineProperty(value, '_request_id', { + value: response.headers.get('request-id'), + enumerable: false, + }) as WithRequestID; +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/request-options.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/request-options.ts new file mode 100644 index 0000000000000000000000000000000000000000..56765e5aa493b7052c234c7dfcc56268c847e595 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/request-options.ts @@ -0,0 +1,93 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import { NullableHeaders } from './headers'; + +import type { BodyInit } from './builtin-types'; +import { Stream } from '../core/streaming'; +import type { HTTPMethod, MergedRequestInit } from './types'; +import { type HeadersLike } from './headers'; + +export type FinalRequestOptions = RequestOptions & { method: HTTPMethod; path: string }; + +export type RequestOptions = { + /** + * The HTTP method for the request (e.g., 'get', 'post', 'put', 'delete'). + */ + method?: HTTPMethod; + + /** + * The URL path for the request. + * + * @example "/v1/foo" + */ + path?: string; + + /** + * Query parameters to include in the request URL. + */ + query?: object | undefined | null; + + /** + * The request body. Can be a string, JSON object, FormData, or other supported types. + */ + body?: unknown; + + /** + * HTTP headers to include with the request. Can be a Headers object, plain object, or array of tuples. + */ + headers?: HeadersLike; + + /** + * The maximum number of times that the client will retry a request in case of a + * temporary failure, like a network error or a 5XX error from the server. + * + * @default 2 + */ + maxRetries?: number; + + stream?: boolean | undefined; + + /** + * The maximum amount of time (in milliseconds) that the client should wait for a response + * from the server before timing out a single request. + * + * @unit milliseconds + */ + timeout?: number; + + /** + * Additional `RequestInit` options to be passed to the underlying `fetch` call. + * These options will be merged with the client's default fetch options. + */ + fetchOptions?: MergedRequestInit; + + /** + * An AbortSignal that can be used to cancel the request. + */ + signal?: AbortSignal | undefined | null; + + /** + * A unique key for this request to enable idempotency. + */ + idempotencyKey?: string; + + /** + * Override the default base URL for this specific request. + */ + defaultBaseURL?: string | undefined; + + __binaryResponse?: boolean | undefined; + __streamClass?: typeof Stream; +}; + +export type EncodedContent = { bodyHeaders: HeadersLike; body: BodyInit }; +export type RequestEncoder = (request: { headers: NullableHeaders; body: unknown }) => EncodedContent; + +export const FallbackEncoder: RequestEncoder = ({ headers, body }) => { + return { + bodyHeaders: { + 'content-type': 'application/json', + }, + body: JSON.stringify(body), + }; +}; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/shim-types.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/shim-types.ts new file mode 100644 index 0000000000000000000000000000000000000000..8ddf7b0ad14b80bc73317cf34beae74991f906bb --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/shim-types.ts @@ -0,0 +1,26 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +/** + * Shims for types that we can't always rely on being available globally. + * + * Note: these only exist at the type-level, there is no corresponding runtime + * version for any of these symbols. + */ + +type NeverToAny = T extends never ? any : T; + +/** @ts-ignore */ +type _DOMReadableStream = globalThis.ReadableStream; + +/** @ts-ignore */ +type _NodeReadableStream = import('stream/web').ReadableStream; + +type _ConditionalNodeReadableStream = + typeof globalThis extends { ReadableStream: any } ? never : _NodeReadableStream; + +type _ReadableStream = NeverToAny< + | ([0] extends [1 & _DOMReadableStream] ? never : _DOMReadableStream) + | ([0] extends [1 & _ConditionalNodeReadableStream] ? never : _ConditionalNodeReadableStream) +>; + +export type { _ReadableStream as ReadableStream }; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/shims.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/shims.ts new file mode 100644 index 0000000000000000000000000000000000000000..98d8cd69eb275604e845e52ab32bcad0ae14abfa --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/shims.ts @@ -0,0 +1,107 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +/** + * This module provides internal shims and utility functions for environments where certain Node.js or global types may not be available. + * + * These are used to ensure we can provide a consistent behaviour between different JavaScript environments and good error + * messages in cases where an environment isn't fully supported. + */ + +import type { Fetch } from './builtin-types'; +import type { ReadableStream } from './shim-types'; + +export function getDefaultFetch(): Fetch { + if (typeof fetch !== 'undefined') { + return fetch as any; + } + + throw new Error( + '`fetch` is not defined as a global; Either pass `fetch` to the client, `new Anthropic({ fetch })` or polyfill the global, `globalThis.fetch = fetch`', + ); +} + +type ReadableStreamArgs = ConstructorParameters; + +export function makeReadableStream(...args: ReadableStreamArgs): ReadableStream { + const ReadableStream = (globalThis as any).ReadableStream; + if (typeof ReadableStream === 'undefined') { + // Note: All of the platforms / runtimes we officially support already define + // `ReadableStream` as a global, so this should only ever be hit on unsupported runtimes. + throw new Error( + '`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`', + ); + } + + return new ReadableStream(...args); +} + +export function ReadableStreamFrom(iterable: Iterable | AsyncIterable): ReadableStream { + let iter: AsyncIterator | Iterator = + Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator](); + + return makeReadableStream({ + start() {}, + async pull(controller: any) { + const { done, value } = await iter.next(); + if (done) { + controller.close(); + } else { + controller.enqueue(value); + } + }, + async cancel() { + await iter.return?.(); + }, + }); +} + +/** + * Most browsers don't yet have async iterable support for ReadableStream, + * and Node has a very different way of reading bytes from its "ReadableStream". + * + * This polyfill was pulled from https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490 + */ +export function ReadableStreamToAsyncIterable(stream: any): AsyncIterableIterator { + if (stream[Symbol.asyncIterator]) return stream; + + const reader = stream.getReader(); + return { + async next() { + try { + const result = await reader.read(); + if (result?.done) reader.releaseLock(); // release lock when stream becomes closed + return result; + } catch (e) { + reader.releaseLock(); // release lock when stream becomes errored + throw e; + } + }, + async return() { + const cancelPromise = reader.cancel(); + reader.releaseLock(); + await cancelPromise; + return { done: true, value: undefined }; + }, + [Symbol.asyncIterator]() { + return this; + }, + }; +} + +/** + * Cancels a ReadableStream we don't need to consume. + * See https://undici.nodejs.org/#/?id=garbage-collection + */ +export async function CancelReadableStream(stream: any): Promise { + if (stream === null || typeof stream !== 'object') return; + + if (stream[Symbol.asyncIterator]) { + await stream[Symbol.asyncIterator]().return?.(); + return; + } + + const reader = stream.getReader(); + const cancelPromise = reader.cancel(); + reader.releaseLock(); + await cancelPromise; +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/stream-utils.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/stream-utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..37f7793cffc8d65cc02ce1750f600e676ced481f --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/stream-utils.ts @@ -0,0 +1,32 @@ +/** + * Most browsers don't yet have async iterable support for ReadableStream, + * and Node has a very different way of reading bytes from its "ReadableStream". + * + * This polyfill was pulled from https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490 + */ +export function ReadableStreamToAsyncIterable(stream: any): AsyncIterableIterator { + if (stream[Symbol.asyncIterator]) return stream; + + const reader = stream.getReader(); + return { + async next() { + try { + const result = await reader.read(); + if (result?.done) reader.releaseLock(); // release lock when stream becomes closed + return result; + } catch (e) { + reader.releaseLock(); // release lock when stream becomes errored + throw e; + } + }, + async return() { + const cancelPromise = reader.cancel(); + reader.releaseLock(); + await cancelPromise; + return { done: true, value: undefined }; + }, + [Symbol.asyncIterator]() { + return this; + }, + }; +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/to-file.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/to-file.ts new file mode 100644 index 0000000000000000000000000000000000000000..289c4eed7054cd102a99e2f42ca730edb62e7770 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/to-file.ts @@ -0,0 +1,159 @@ +import { BlobPart, getName, makeFile, isAsyncIterable } from './uploads'; +import type { FilePropertyBag } from './builtin-types'; +import { checkFileSupport } from './uploads'; + +type BlobLikePart = string | ArrayBuffer | ArrayBufferView | BlobLike | DataView; + +/** + * Intended to match DOM Blob, node-fetch Blob, node:buffer Blob, etc. + * Don't add arrayBuffer here, node-fetch doesn't have it + */ +interface BlobLike { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/size) */ + readonly size: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/type) */ + readonly type: string; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/text) */ + text(): Promise; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/slice) */ + slice(start?: number, end?: number): BlobLike; +} + +/** + * This check adds the arrayBuffer() method type because it is available and used at runtime + */ +const isBlobLike = (value: any): value is BlobLike & { arrayBuffer(): Promise } => + value != null && + typeof value === 'object' && + typeof value.size === 'number' && + typeof value.type === 'string' && + typeof value.text === 'function' && + typeof value.slice === 'function' && + typeof value.arrayBuffer === 'function'; + +/** + * Intended to match DOM File, node:buffer File, undici File, etc. + */ +interface FileLike extends BlobLike { + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/lastModified) */ + readonly lastModified: number; + /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/name) */ + readonly name?: string | undefined; +} + +/** + * This check adds the arrayBuffer() method type because it is available and used at runtime + */ +const isFileLike = (value: any): value is FileLike & { arrayBuffer(): Promise } => + value != null && + typeof value === 'object' && + typeof value.name === 'string' && + typeof value.lastModified === 'number' && + isBlobLike(value); + +/** + * Intended to match DOM Response, node-fetch Response, undici Response, etc. + */ +export interface ResponseLike { + url: string; + blob(): Promise; +} + +const isResponseLike = (value: any): value is ResponseLike => + value != null && + typeof value === 'object' && + typeof value.url === 'string' && + typeof value.blob === 'function'; + +export type ToFileInput = + | FileLike + | ResponseLike + | Exclude + | AsyncIterable; + +/** + * Helper for creating a {@link File} to pass to an SDK upload method from a variety of different data formats + * @param value the raw content of the file. Can be an {@link Uploadable}, {@link BlobLikePart}, or {@link AsyncIterable} of {@link BlobLikePart}s + * @param {string=} name the name of the file. If omitted, toFile will try to determine a file name from bits if possible + * @param {Object=} options additional properties + * @param {string=} options.type the MIME type of the content + * @param {number=} options.lastModified the last modified timestamp + * @returns a {@link File} with the given properties + */ +export async function toFile( + value: ToFileInput | PromiseLike, + name?: string | null | undefined, + options?: FilePropertyBag | undefined, +): Promise { + checkFileSupport(); + + // If it's a promise, resolve it. + value = await value; + + name ||= getName(value); + + // If we've been given a `File` we don't need to do anything if the name / options + // have not been customised. + if (isFileLike(value)) { + if (value instanceof File && name == null && options == null) { + return value; + } + return makeFile([await value.arrayBuffer()], name ?? value.name, { + type: value.type, + lastModified: value.lastModified, + ...options, + }); + } + + if (isResponseLike(value)) { + const blob = await value.blob(); + name ||= new URL(value.url).pathname.split(/[\\/]/).pop(); + + return makeFile(await getBytes(blob), name, options); + } + + const parts = await getBytes(value); + + if (!options?.type) { + const type = parts.find((part) => typeof part === 'object' && 'type' in part && part.type); + if (typeof type === 'string') { + options = { ...options, type }; + } + } + + return makeFile(parts, name, options); +} + +async function getBytes(value: BlobLikePart | AsyncIterable): Promise> { + let parts: Array = []; + if ( + typeof value === 'string' || + ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc. + value instanceof ArrayBuffer + ) { + parts.push(value); + } else if (isBlobLike(value)) { + parts.push(value instanceof Blob ? value : await value.arrayBuffer()); + } else if ( + isAsyncIterable(value) // includes Readable, ReadableStream, etc. + ) { + for await (const chunk of value) { + parts.push(...(await getBytes(chunk as BlobLikePart))); // TODO, consider validating? + } + } else { + const constructor = value?.constructor?.name; + throw new Error( + `Unexpected data type: ${typeof value}${ + constructor ? `; constructor: ${constructor}` : '' + }${propsForError(value)}`, + ); + } + + return parts; +} + +function propsForError(value: unknown): string { + if (typeof value !== 'object' || value === null) return ''; + const props = Object.getOwnPropertyNames(value); + return `; props: [${props.map((p) => `"${p}"`).join(', ')}]`; +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/types.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/types.ts new file mode 100644 index 0000000000000000000000000000000000000000..b668dfc0fe609e1f1c151104fab9c6bc39a7483e --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/types.ts @@ -0,0 +1,95 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +export type PromiseOrValue = T | Promise; +export type HTTPMethod = 'get' | 'post' | 'put' | 'patch' | 'delete'; + +export type KeysEnum = { [P in keyof Required]: true }; + +export type FinalizedRequestInit = RequestInit & { headers: Headers }; + +type NotAny = [0] extends [1 & T] ? never : T; + +/** + * Some environments overload the global fetch function, and Parameters only gets the last signature. + */ +type OverloadedParameters = + T extends ( + { + (...args: infer A): unknown; + (...args: infer B): unknown; + (...args: infer C): unknown; + (...args: infer D): unknown; + } + ) ? + A | B | C | D + : T extends ( + { + (...args: infer A): unknown; + (...args: infer B): unknown; + (...args: infer C): unknown; + } + ) ? + A | B | C + : T extends ( + { + (...args: infer A): unknown; + (...args: infer B): unknown; + } + ) ? + A | B + : T extends (...args: infer A) => unknown ? A + : never; + +/* eslint-disable */ +/** + * These imports attempt to get types from a parent package's dependencies. + * Unresolved bare specifiers can trigger [automatic type acquisition][1] in some projects, which + * would cause typescript to show types not present at runtime. To avoid this, we import + * directly from parent node_modules folders. + * + * We need to check multiple levels because we don't know what directory structure we'll be in. + * For example, pnpm generates directories like this: + * ``` + * node_modules + * ├── .pnpm + * │ └── pkg@1.0.0 + * │ └── node_modules + * │ └── pkg + * │ └── internal + * │ └── types.d.ts + * ├── pkg -> .pnpm/pkg@1.0.0/node_modules/pkg + * └── undici + * ``` + * + * [1]: https://www.typescriptlang.org/tsconfig/#typeAcquisition + */ +/** @ts-ignore For users with \@types/node */ +type UndiciTypesRequestInit = NotAny | NotAny | NotAny | NotAny | NotAny | NotAny | NotAny | NotAny | NotAny | NotAny; +/** @ts-ignore For users with undici */ +type UndiciRequestInit = NotAny | NotAny | NotAny | NotAny | NotAny | NotAny | NotAny | NotAny | NotAny | NotAny; +/** @ts-ignore For users with \@types/bun */ +type BunRequestInit = globalThis.FetchRequestInit; +/** @ts-ignore For users with node-fetch@2 */ +type NodeFetch2RequestInit = NotAny | NotAny | NotAny | NotAny | NotAny | NotAny | NotAny | NotAny | NotAny | NotAny; +/** @ts-ignore For users with node-fetch@3, doesn't need file extension because types are at ./@types/index.d.ts */ +type NodeFetch3RequestInit = NotAny | NotAny | NotAny | NotAny | NotAny | NotAny | NotAny | NotAny | NotAny | NotAny; +/** @ts-ignore For users who use Deno */ +type FetchRequestInit = NonNullable[1]>; +/* eslint-enable */ + +type RequestInits = + | NotAny + | NotAny + | NotAny + | NotAny + | NotAny + | NotAny + | NotAny; + +/** + * This type contains `RequestInit` options that may be available on the current runtime, + * including per-platform extensions like `dispatcher`, `agent`, `client`, etc. + */ +export type MergedRequestInit = RequestInits & + /** We don't include these in the types as they'll be overridden for every request. */ + Partial>; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/uploads.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/uploads.ts new file mode 100644 index 0000000000000000000000000000000000000000..93d52a7ce12fbe9cca6fa6b654bad18739626688 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/uploads.ts @@ -0,0 +1,193 @@ +import { type RequestOptions } from './request-options'; +import type { FilePropertyBag, Fetch } from './builtin-types'; +import type { BaseAnthropic } from '../client'; +import { ReadableStreamFrom } from './shims'; + +export type BlobPart = string | ArrayBuffer | ArrayBufferView | Blob | DataView; +type FsReadStream = AsyncIterable & { path: string | { toString(): string } }; + +// https://github.com/oven-sh/bun/issues/5980 +interface BunFile extends Blob { + readonly name?: string | undefined; +} + +export const checkFileSupport = () => { + if (typeof File === 'undefined') { + const { process } = globalThis as any; + const isOldNode = + typeof process?.versions?.node === 'string' && parseInt(process.versions.node.split('.')) < 20; + throw new Error( + '`File` is not defined as a global, which is required for file uploads.' + + (isOldNode ? + " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`." + : ''), + ); + } +}; + +/** + * Typically, this is a native "File" class. + * + * We provide the {@link toFile} utility to convert a variety of objects + * into the File class. + * + * For convenience, you can also pass a fetch Response, or in Node, + * the result of fs.createReadStream(). + */ +export type Uploadable = File | Response | FsReadStream | BunFile; + +/** + * Construct a `File` instance. This is used to ensure a helpful error is thrown + * for environments that don't define a global `File` yet. + */ +export function makeFile( + fileBits: BlobPart[], + fileName: string | undefined, + options?: FilePropertyBag, +): File { + checkFileSupport(); + return new File(fileBits as any, fileName ?? 'unknown_file', options); +} + +export function getName(value: any): string | undefined { + return ( + ( + (typeof value === 'object' && + value !== null && + (('name' in value && value.name && String(value.name)) || + ('url' in value && value.url && String(value.url)) || + ('filename' in value && value.filename && String(value.filename)) || + ('path' in value && value.path && String(value.path)))) || + '' + ) + .split(/[\\/]/) + .pop() || undefined + ); +} + +export const isAsyncIterable = (value: any): value is AsyncIterable => + value != null && typeof value === 'object' && typeof value[Symbol.asyncIterator] === 'function'; + +/** + * Returns a multipart/form-data request if any part of the given request body contains a File / Blob value. + * Otherwise returns the request as is. + */ +export const maybeMultipartFormRequestOptions = async ( + opts: RequestOptions, + fetch: BaseAnthropic | Fetch, +): Promise => { + if (!hasUploadableValue(opts.body)) return opts; + + return { ...opts, body: await createForm(opts.body, fetch) }; +}; + +type MultipartFormRequestOptions = Omit & { body: unknown }; + +export const multipartFormRequestOptions = async ( + opts: MultipartFormRequestOptions, + fetch: BaseAnthropic | Fetch, +): Promise => { + return { ...opts, body: await createForm(opts.body, fetch) }; +}; + +const supportsFormDataMap = /* @__PURE__ */ new WeakMap>(); + +/** + * node-fetch doesn't support the global FormData object in recent node versions. Instead of sending + * properly-encoded form data, it just stringifies the object, resulting in a request body of "[object FormData]". + * This function detects if the fetch function provided supports the global FormData object to avoid + * confusing error messages later on. + */ +function supportsFormData(fetchObject: BaseAnthropic | Fetch): Promise { + const fetch: Fetch = typeof fetchObject === 'function' ? fetchObject : (fetchObject as any).fetch; + const cached = supportsFormDataMap.get(fetch); + if (cached) return cached; + const promise = (async () => { + try { + const FetchResponse = ( + 'Response' in fetch ? + fetch.Response + : (await fetch('data:,')).constructor) as typeof Response; + const data = new FormData(); + if (data.toString() === (await new FetchResponse(data).text())) { + return false; + } + return true; + } catch { + // avoid false negatives + return true; + } + })(); + supportsFormDataMap.set(fetch, promise); + return promise; +} + +export const createForm = async >( + body: T | undefined, + fetch: BaseAnthropic | Fetch, +): Promise => { + if (!(await supportsFormData(fetch))) { + throw new TypeError( + 'The provided fetch function does not support file uploads with the current global FormData class.', + ); + } + const form = new FormData(); + await Promise.all(Object.entries(body || {}).map(([key, value]) => addFormValue(form, key, value))); + return form; +}; + +// We check for Blob not File because Bun.File doesn't inherit from File, +// but they both inherit from Blob and have a `name` property at runtime. +const isNamedBlob = (value: unknown): value is Blob => value instanceof Blob && 'name' in value; + +const isUploadable = (value: unknown) => + typeof value === 'object' && + value !== null && + (value instanceof Response || isAsyncIterable(value) || isNamedBlob(value)); + +const hasUploadableValue = (value: unknown): boolean => { + if (isUploadable(value)) return true; + if (Array.isArray(value)) return value.some(hasUploadableValue); + if (value && typeof value === 'object') { + for (const k in value) { + if (hasUploadableValue((value as any)[k])) return true; + } + } + return false; +}; + +const addFormValue = async (form: FormData, key: string, value: unknown): Promise => { + if (value === undefined) return; + if (value == null) { + throw new TypeError( + `Received null for "${key}"; to pass null in FormData, you must use the string 'null'`, + ); + } + + // TODO: make nested formats configurable + if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') { + form.append(key, String(value)); + } else if (value instanceof Response) { + let options = {} as FilePropertyBag; + const contentType = value.headers.get('Content-Type'); + if (contentType) { + options = { type: contentType }; + } + + form.append(key, makeFile([await value.blob()], getName(value), options)); + } else if (isAsyncIterable(value)) { + form.append(key, makeFile([await new Response(ReadableStreamFrom(value)).blob()], getName(value))); + } else if (isNamedBlob(value)) { + form.append(key, makeFile([value], getName(value), { type: value.type })); + } else if (Array.isArray(value)) { + await Promise.all(value.map((entry) => addFormValue(form, key + '[]', entry))); + } else if (typeof value === 'object') { + await Promise.all( + Object.entries(value).map(([name, prop]) => addFormValue(form, `${key}[${name}]`, prop)), + ); + } else { + throw new TypeError( + `Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${value} instead`, + ); + } +}; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..3cbfacce29a05b720a183ce2c4680a40a8463fea --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils.ts @@ -0,0 +1,8 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +export * from './utils/values'; +export * from './utils/base64'; +export * from './utils/env'; +export * from './utils/log'; +export * from './utils/uuid'; +export * from './utils/sleep'; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/base64.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/base64.ts new file mode 100644 index 0000000000000000000000000000000000000000..f028d34aa3b6e70f4d9a2d6885165c5876eb6a88 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/base64.ts @@ -0,0 +1,40 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import { AnthropicError } from '../../core/error'; +import { encodeUTF8 } from './bytes'; + +export const toBase64 = (data: string | Uint8Array | null | undefined): string => { + if (!data) return ''; + + if (typeof (globalThis as any).Buffer !== 'undefined') { + return (globalThis as any).Buffer.from(data).toString('base64'); + } + + if (typeof data === 'string') { + data = encodeUTF8(data); + } + + if (typeof btoa !== 'undefined') { + return btoa(String.fromCharCode.apply(null, data as any)); + } + + throw new AnthropicError('Cannot generate base64 string; Expected `Buffer` or `btoa` to be defined'); +}; + +export const fromBase64 = (str: string): Uint8Array => { + if (typeof (globalThis as any).Buffer !== 'undefined') { + const buf = (globalThis as any).Buffer.from(str, 'base64'); + return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength); + } + + if (typeof atob !== 'undefined') { + const bstr = atob(str); + const buf = new Uint8Array(bstr.length); + for (let i = 0; i < bstr.length; i++) { + buf[i] = bstr.charCodeAt(i); + } + return buf; + } + + throw new AnthropicError('Cannot decode base64 string; Expected `Buffer` or `atob` to be defined'); +}; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/bytes.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/bytes.ts new file mode 100644 index 0000000000000000000000000000000000000000..8da627abe133306f787a3d0c4d7182ab3170804b --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/bytes.ts @@ -0,0 +1,32 @@ +export function concatBytes(buffers: Uint8Array[]): Uint8Array { + let length = 0; + for (const buffer of buffers) { + length += buffer.length; + } + const output = new Uint8Array(length); + let index = 0; + for (const buffer of buffers) { + output.set(buffer, index); + index += buffer.length; + } + + return output; +} + +let encodeUTF8_: (str: string) => Uint8Array; +export function encodeUTF8(str: string) { + let encoder; + return ( + encodeUTF8_ ?? + ((encoder = new (globalThis as any).TextEncoder()), (encodeUTF8_ = encoder.encode.bind(encoder))) + )(str); +} + +let decodeUTF8_: (bytes: Uint8Array) => string; +export function decodeUTF8(bytes: Uint8Array) { + let decoder; + return ( + decodeUTF8_ ?? + ((decoder = new (globalThis as any).TextDecoder()), (decodeUTF8_ = decoder.decode.bind(decoder))) + )(bytes); +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/env.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/env.ts new file mode 100644 index 0000000000000000000000000000000000000000..2d8480077c2302e9c2f376fc56afccb4330f94d8 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/env.ts @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +/** + * Read an environment variable. + * + * Trims beginning and trailing whitespace. + * + * Will return undefined if the environment variable doesn't exist or cannot be accessed. + */ +export const readEnv = (env: string): string | undefined => { + if (typeof (globalThis as any).process !== 'undefined') { + return (globalThis as any).process.env?.[env]?.trim() ?? undefined; + } + if (typeof (globalThis as any).Deno !== 'undefined') { + return (globalThis as any).Deno.env?.get?.(env)?.trim(); + } + return undefined; +}; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/log.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/log.ts new file mode 100644 index 0000000000000000000000000000000000000000..aa0dc3bb4689b31e41bab9bddcc24a9e1587a2ca --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/log.ts @@ -0,0 +1,127 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import { hasOwn } from './values'; +import { type BaseAnthropic } from '../../client'; +import { RequestOptions } from '../request-options'; + +type LogFn = (message: string, ...rest: unknown[]) => void; +export type Logger = { + error: LogFn; + warn: LogFn; + info: LogFn; + debug: LogFn; +}; +export type LogLevel = 'off' | 'error' | 'warn' | 'info' | 'debug'; + +const levelNumbers = { + off: 0, + error: 200, + warn: 300, + info: 400, + debug: 500, +}; + +export const parseLogLevel = ( + maybeLevel: string | undefined, + sourceName: string, + client: BaseAnthropic, +): LogLevel | undefined => { + if (!maybeLevel) { + return undefined; + } + if (hasOwn(levelNumbers, maybeLevel)) { + return maybeLevel; + } + loggerFor(client).warn( + `${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify( + Object.keys(levelNumbers), + )}`, + ); + return undefined; +}; + +function noop() {} + +function makeLogFn(fnLevel: keyof Logger, logger: Logger | undefined, logLevel: LogLevel) { + if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) { + return noop; + } else { + // Don't wrap logger functions, we want the stacktrace intact! + return logger[fnLevel].bind(logger); + } +} + +const noopLogger = { + error: noop, + warn: noop, + info: noop, + debug: noop, +}; + +let cachedLoggers = /* @__PURE__ */ new WeakMap(); + +export function loggerFor(client: BaseAnthropic): Logger { + const logger = client.logger; + const logLevel = client.logLevel ?? 'off'; + if (!logger) { + return noopLogger; + } + + const cachedLogger = cachedLoggers.get(logger); + if (cachedLogger && cachedLogger[0] === logLevel) { + return cachedLogger[1]; + } + + const levelLogger = { + error: makeLogFn('error', logger, logLevel), + warn: makeLogFn('warn', logger, logLevel), + info: makeLogFn('info', logger, logLevel), + debug: makeLogFn('debug', logger, logLevel), + }; + + cachedLoggers.set(logger, [logLevel, levelLogger]); + + return levelLogger; +} + +export const formatRequestDetails = (details: { + options?: RequestOptions | undefined; + headers?: Headers | Record | undefined; + retryOfRequestLogID?: string | undefined; + retryOf?: string | undefined; + url?: string | undefined; + status?: number | undefined; + method?: string | undefined; + durationMs?: number | undefined; + message?: unknown; + body?: unknown; +}) => { + if (details.options) { + details.options = { ...details.options }; + delete details.options['headers']; // redundant + leaks internals + } + if (details.headers) { + details.headers = Object.fromEntries( + (details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map( + ([name, value]) => [ + name, + ( + name.toLowerCase() === 'x-api-key' || + name.toLowerCase() === 'authorization' || + name.toLowerCase() === 'cookie' || + name.toLowerCase() === 'set-cookie' + ) ? + '***' + : value, + ], + ), + ); + } + if ('retryOfRequestLogID' in details) { + if (details.retryOfRequestLogID) { + details.retryOf = details.retryOfRequestLogID; + } + delete details.retryOfRequestLogID; + } + return details; +}; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/path.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/path.ts new file mode 100644 index 0000000000000000000000000000000000000000..7606a0edaa5f1c7c517826f800296877b19105da --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/path.ts @@ -0,0 +1,88 @@ +import { AnthropicError } from '../../core/error'; + +/** + * Percent-encode everything that isn't safe to have in a path without encoding safe chars. + * + * Taken from https://datatracker.ietf.org/doc/html/rfc3986#section-3.3: + * > unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" + * > sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "=" + * > pchar = unreserved / pct-encoded / sub-delims / ":" / "@" + */ +export function encodeURIPath(str: string) { + return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent); +} + +const EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null)); + +export const createPathTagFunction = (pathEncoder = encodeURIPath) => + function path(statics: readonly string[], ...params: readonly unknown[]): string { + // If there are no params, no processing is needed. + if (statics.length === 1) return statics[0]!; + + let postPath = false; + const invalidSegments = []; + const path = statics.reduce((previousValue, currentValue, index) => { + if (/[?#]/.test(currentValue)) { + postPath = true; + } + const value = params[index]; + let encoded = (postPath ? encodeURIComponent : pathEncoder)('' + value); + if ( + index !== params.length && + (value == null || + (typeof value === 'object' && + // handle values from other realms + value.toString === + Object.getPrototypeOf(Object.getPrototypeOf((value as any).hasOwnProperty ?? EMPTY) ?? EMPTY) + ?.toString)) + ) { + encoded = value + ''; + invalidSegments.push({ + start: previousValue.length + currentValue.length, + length: encoded.length, + error: `Value of type ${Object.prototype.toString + .call(value) + .slice(8, -1)} is not a valid path parameter`, + }); + } + return previousValue + currentValue + (index === params.length ? '' : encoded); + }, ''); + + const pathOnly = path.split(/[?#]/, 1)[0]!; + const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi; + let match; + + // Find all invalid segments + while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) { + invalidSegments.push({ + start: match.index, + length: match[0].length, + error: `Value "${match[0]}" can\'t be safely passed as a path parameter`, + }); + } + + invalidSegments.sort((a, b) => a.start - b.start); + + if (invalidSegments.length > 0) { + let lastEnd = 0; + const underline = invalidSegments.reduce((acc, segment) => { + const spaces = ' '.repeat(segment.start - lastEnd); + const arrows = '^'.repeat(segment.length); + lastEnd = segment.start + segment.length; + return acc + spaces + arrows; + }, ''); + + throw new AnthropicError( + `Path parameters result in path with invalid segments:\n${invalidSegments + .map((e) => e.error) + .join('\n')}\n${path}\n${underline}`, + ); + } + + return path; + }; + +/** + * URI-encodes path params and ensures no unsafe /./ or /../ path segments are introduced. + */ +export const path = /* @__PURE__ */ createPathTagFunction(encodeURIPath); diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/sleep.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/sleep.ts new file mode 100644 index 0000000000000000000000000000000000000000..65e52962bbb288c4a2f19fbe14b7ffb9baba6487 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/sleep.ts @@ -0,0 +1,3 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms)); diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/uuid.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/uuid.ts new file mode 100644 index 0000000000000000000000000000000000000000..b0e53aaf7ef092c1bd64847211ab62b27bb18869 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/uuid.ts @@ -0,0 +1,17 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +/** + * https://stackoverflow.com/a/2117523 + */ +export let uuid4 = function () { + const { crypto } = globalThis as any; + if (crypto?.randomUUID) { + uuid4 = crypto.randomUUID.bind(crypto); + return crypto.randomUUID(); + } + const u8 = new Uint8Array(1); + const randomByte = crypto ? () => crypto.getRandomValues(u8)[0]! : () => (Math.random() * 0xff) & 0xff; + return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, (c) => + (+c ^ (randomByte() & (15 >> (+c / 4)))).toString(16), + ); +}; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/values.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/values.ts new file mode 100644 index 0000000000000000000000000000000000000000..7018fe9a441600091ce1c3e229d03926b1506c3d --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/internal/utils/values.ts @@ -0,0 +1,105 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import { AnthropicError } from '../../core/error'; + +// https://url.spec.whatwg.org/#url-scheme-string +const startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i; + +export const isAbsoluteURL = (url: string): boolean => { + return startsWithSchemeRegexp.test(url); +}; + +export let isArray = (val: unknown): val is unknown[] => ((isArray = Array.isArray), isArray(val)); +export let isReadonlyArray = isArray as (val: unknown) => val is readonly unknown[]; + +/** Returns an object if the given value isn't an object, otherwise returns as-is */ +export function maybeObj(x: unknown): object { + if (typeof x !== 'object') { + return {}; + } + + return x ?? {}; +} + +// https://stackoverflow.com/a/34491287 +export function isEmptyObj(obj: Object | null | undefined): boolean { + if (!obj) return true; + for (const _k in obj) return false; + return true; +} + +// https://eslint.org/docs/latest/rules/no-prototype-builtins +export function hasOwn(obj: T, key: PropertyKey): key is keyof T { + return Object.prototype.hasOwnProperty.call(obj, key); +} + +export function isObj(obj: unknown): obj is Record { + return obj != null && typeof obj === 'object' && !Array.isArray(obj); +} + +export const ensurePresent = (value: T | null | undefined): T => { + if (value == null) { + throw new AnthropicError(`Expected a value to be given but received ${value} instead.`); + } + + return value; +}; + +export const validatePositiveInteger = (name: string, n: unknown): number => { + if (typeof n !== 'number' || !Number.isInteger(n)) { + throw new AnthropicError(`${name} must be an integer`); + } + if (n < 0) { + throw new AnthropicError(`${name} must be a positive integer`); + } + return n; +}; + +export const coerceInteger = (value: unknown): number => { + if (typeof value === 'number') return Math.round(value); + if (typeof value === 'string') return parseInt(value, 10); + + throw new AnthropicError(`Could not coerce ${value} (type: ${typeof value}) into a number`); +}; + +export const coerceFloat = (value: unknown): number => { + if (typeof value === 'number') return value; + if (typeof value === 'string') return parseFloat(value); + + throw new AnthropicError(`Could not coerce ${value} (type: ${typeof value}) into a number`); +}; + +export const coerceBoolean = (value: unknown): boolean => { + if (typeof value === 'boolean') return value; + if (typeof value === 'string') return value === 'true'; + return Boolean(value); +}; + +export const maybeCoerceInteger = (value: unknown): number | undefined => { + if (value === undefined) { + return undefined; + } + return coerceInteger(value); +}; + +export const maybeCoerceFloat = (value: unknown): number | undefined => { + if (value === undefined) { + return undefined; + } + return coerceFloat(value); +}; + +export const maybeCoerceBoolean = (value: unknown): boolean | undefined => { + if (value === undefined) { + return undefined; + } + return coerceBoolean(value); +}; + +export const safeJSON = (text: string) => { + try { + return JSON.parse(text); + } catch (err) { + return undefined; + } +}; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/lib/.keep b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/lib/.keep new file mode 100644 index 0000000000000000000000000000000000000000..7554f8b20ae58485df49010107f79349db1c5943 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/lib/.keep @@ -0,0 +1,4 @@ +File generated from our OpenAPI spec by Stainless. + +This directory can be used to store custom files to expand the SDK. +It is ignored by Stainless code generation and its content (other than this keep file) won't be touched. diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/lib/BetaMessageStream.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/lib/BetaMessageStream.ts new file mode 100644 index 0000000000000000000000000000000000000000..4160aa78b122f3b6ec799b9bff8b55b48c95512b --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/lib/BetaMessageStream.ts @@ -0,0 +1,727 @@ +import { isAbortError } from '../internal/errors'; +import { AnthropicError, APIUserAbortError } from '../error'; +import { + type BetaContentBlock, + Messages as BetaMessages, + type BetaMessage, + type BetaRawMessageStreamEvent as BetaMessageStreamEvent, + type BetaMessageParam, + type MessageCreateParams as BetaMessageCreateParams, + type MessageCreateParamsBase as BetaMessageCreateParamsBase, + type BetaTextBlock, + type BetaTextCitation, + type BetaToolUseBlock, + type BetaServerToolUseBlock, + type BetaMCPToolUseBlock, +} from '../resources/beta/messages/messages'; +import { Stream } from '../streaming'; +import { partialParse } from '../_vendor/partial-json-parser/parser'; +import { type RequestOptions } from '../internal/request-options'; + +export interface MessageStreamEvents { + connect: () => void; + streamEvent: (event: BetaMessageStreamEvent, snapshot: BetaMessage) => void; + text: (textDelta: string, textSnapshot: string) => void; + citation: (citation: BetaTextCitation, citationsSnapshot: BetaTextCitation[]) => void; + inputJson: (partialJson: string, jsonSnapshot: unknown) => void; + thinking: (thinkingDelta: string, thinkingSnapshot: string) => void; + signature: (signature: string) => void; + message: (message: BetaMessage) => void; + contentBlock: (content: BetaContentBlock) => void; + finalMessage: (message: BetaMessage) => void; + error: (error: AnthropicError) => void; + abort: (error: APIUserAbortError) => void; + end: () => void; +} + +type MessageStreamEventListeners = { + listener: MessageStreamEvents[Event]; + once?: boolean; +}[]; + +const JSON_BUF_PROPERTY = '__json_buf'; + +export type TracksToolInput = BetaToolUseBlock | BetaServerToolUseBlock | BetaMCPToolUseBlock; + +function tracksToolInput(content: BetaContentBlock): content is TracksToolInput { + return content.type === 'tool_use' || content.type === 'server_tool_use' || content.type === 'mcp_tool_use'; +} + +export class BetaMessageStream implements AsyncIterable { + messages: BetaMessageParam[] = []; + receivedMessages: BetaMessage[] = []; + #currentMessageSnapshot: BetaMessage | undefined; + + controller: AbortController = new AbortController(); + + #connectedPromise: Promise; + #resolveConnectedPromise: (response: Response | null) => void = () => {}; + #rejectConnectedPromise: (error: AnthropicError) => void = () => {}; + + #endPromise: Promise; + #resolveEndPromise: () => void = () => {}; + #rejectEndPromise: (error: AnthropicError) => void = () => {}; + + #listeners: { [Event in keyof MessageStreamEvents]?: MessageStreamEventListeners } = {}; + + #ended = false; + #errored = false; + #aborted = false; + #catchingPromiseCreated = false; + #response: Response | null | undefined; + #request_id: string | null | undefined; + + constructor() { + this.#connectedPromise = new Promise((resolve, reject) => { + this.#resolveConnectedPromise = resolve; + this.#rejectConnectedPromise = reject; + }); + + this.#endPromise = new Promise((resolve, reject) => { + this.#resolveEndPromise = resolve; + this.#rejectEndPromise = reject; + }); + + // Don't let these promises cause unhandled rejection errors. + // we will manually cause an unhandled rejection error later + // if the user hasn't registered any error listener or called + // any promise-returning method. + this.#connectedPromise.catch(() => {}); + this.#endPromise.catch(() => {}); + } + + get response(): Response | null | undefined { + return this.#response; + } + + get request_id(): string | null | undefined { + return this.#request_id; + } + + /** + * Returns the `MessageStream` data, the raw `Response` instance and the ID of the request, + * returned vie the `request-id` header which is useful for debugging requests and resporting + * issues to Anthropic. + * + * This is the same as the `APIPromise.withResponse()` method. + * + * This method will raise an error if you created the stream using `MessageStream.fromReadableStream` + * as no `Response` is available. + */ + async withResponse(): Promise<{ + data: BetaMessageStream; + response: Response; + request_id: string | null | undefined; + }> { + const response = await this.#connectedPromise; + if (!response) { + throw new Error('Could not resolve a `Response` object'); + } + + return { + data: this, + response, + request_id: response.headers.get('request-id'), + }; + } + + /** + * Intended for use on the frontend, consuming a stream produced with + * `.toReadableStream()` on the backend. + * + * Note that messages sent to the model do not appear in `.on('message')` + * in this context. + */ + static fromReadableStream(stream: ReadableStream): BetaMessageStream { + const runner = new BetaMessageStream(); + runner._run(() => runner._fromReadableStream(stream)); + return runner; + } + + static createMessage( + messages: BetaMessages, + params: BetaMessageCreateParamsBase, + options?: RequestOptions, + ): BetaMessageStream { + const runner = new BetaMessageStream(); + for (const message of params.messages) { + runner._addMessageParam(message); + } + runner._run(() => + runner._createMessage( + messages, + { ...params, stream: true }, + { ...options, headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'stream' } }, + ), + ); + return runner; + } + + protected _run(executor: () => Promise) { + executor().then(() => { + this._emitFinal(); + this._emit('end'); + }, this.#handleError); + } + + protected _addMessageParam(message: BetaMessageParam) { + this.messages.push(message); + } + + protected _addMessage(message: BetaMessage, emit = true) { + this.receivedMessages.push(message); + if (emit) { + this._emit('message', message); + } + } + + protected async _createMessage( + messages: BetaMessages, + params: BetaMessageCreateParams, + options?: RequestOptions, + ): Promise { + const signal = options?.signal; + let abortHandler: (() => void) | undefined; + if (signal) { + if (signal.aborted) this.controller.abort(); + abortHandler = this.controller.abort.bind(this.controller); + signal.addEventListener('abort', abortHandler); + } + try { + this.#beginRequest(); + const { response, data: stream } = await messages + .create({ ...params, stream: true }, { ...options, signal: this.controller.signal }) + .withResponse(); + this._connected(response); + for await (const event of stream) { + this.#addStreamEvent(event); + } + if (stream.controller.signal?.aborted) { + throw new APIUserAbortError(); + } + this.#endRequest(); + } finally { + if (signal && abortHandler) { + signal.removeEventListener('abort', abortHandler); + } + } + } + + protected _connected(response: Response | null) { + if (this.ended) return; + this.#response = response; + this.#request_id = response?.headers.get('request-id'); + this.#resolveConnectedPromise(response); + this._emit('connect'); + } + + get ended(): boolean { + return this.#ended; + } + + get errored(): boolean { + return this.#errored; + } + + get aborted(): boolean { + return this.#aborted; + } + + abort() { + this.controller.abort(); + } + + /** + * Adds the listener function to the end of the listeners array for the event. + * No checks are made to see if the listener has already been added. Multiple calls passing + * the same combination of event and listener will result in the listener being added, and + * called, multiple times. + * @returns this MessageStream, so that calls can be chained + */ + on(event: Event, listener: MessageStreamEvents[Event]): this { + const listeners: MessageStreamEventListeners = + this.#listeners[event] || (this.#listeners[event] = []); + listeners.push({ listener }); + return this; + } + + /** + * Removes the specified listener from the listener array for the event. + * off() will remove, at most, one instance of a listener from the listener array. If any single + * listener has been added multiple times to the listener array for the specified event, then + * off() must be called multiple times to remove each instance. + * @returns this MessageStream, so that calls can be chained + */ + off(event: Event, listener: MessageStreamEvents[Event]): this { + const listeners = this.#listeners[event]; + if (!listeners) return this; + const index = listeners.findIndex((l) => l.listener === listener); + if (index >= 0) listeners.splice(index, 1); + return this; + } + + /** + * Adds a one-time listener function for the event. The next time the event is triggered, + * this listener is removed and then invoked. + * @returns this MessageStream, so that calls can be chained + */ + once(event: Event, listener: MessageStreamEvents[Event]): this { + const listeners: MessageStreamEventListeners = + this.#listeners[event] || (this.#listeners[event] = []); + listeners.push({ listener, once: true }); + return this; + } + + /** + * This is similar to `.once()`, but returns a Promise that resolves the next time + * the event is triggered, instead of calling a listener callback. + * @returns a Promise that resolves the next time given event is triggered, + * or rejects if an error is emitted. (If you request the 'error' event, + * returns a promise that resolves with the error). + * + * Example: + * + * const message = await stream.emitted('message') // rejects if the stream errors + */ + emitted( + event: Event, + ): Promise< + Parameters extends [infer Param] ? Param + : Parameters extends [] ? void + : Parameters + > { + return new Promise((resolve, reject) => { + this.#catchingPromiseCreated = true; + if (event !== 'error') this.once('error', reject); + this.once(event, resolve as any); + }); + } + + async done(): Promise { + this.#catchingPromiseCreated = true; + await this.#endPromise; + } + + get currentMessage(): BetaMessage | undefined { + return this.#currentMessageSnapshot; + } + + #getFinalMessage(): BetaMessage { + if (this.receivedMessages.length === 0) { + throw new AnthropicError('stream ended without producing a Message with role=assistant'); + } + return this.receivedMessages.at(-1)!; + } + + /** + * @returns a promise that resolves with the the final assistant Message response, + * or rejects if an error occurred or the stream ended prematurely without producing a Message. + */ + async finalMessage(): Promise { + await this.done(); + return this.#getFinalMessage(); + } + + #getFinalText(): string { + if (this.receivedMessages.length === 0) { + throw new AnthropicError('stream ended without producing a Message with role=assistant'); + } + const textBlocks = this.receivedMessages + .at(-1)! + .content.filter((block): block is BetaTextBlock => block.type === 'text') + .map((block) => block.text); + if (textBlocks.length === 0) { + throw new AnthropicError('stream ended without producing a content block with type=text'); + } + return textBlocks.join(' '); + } + + /** + * @returns a promise that resolves with the the final assistant Message's text response, concatenated + * together if there are more than one text blocks. + * Rejects if an error occurred or the stream ended prematurely without producing a Message. + */ + async finalText(): Promise { + await this.done(); + return this.#getFinalText(); + } + + #handleError = (error: unknown) => { + this.#errored = true; + if (isAbortError(error)) { + error = new APIUserAbortError(); + } + if (error instanceof APIUserAbortError) { + this.#aborted = true; + return this._emit('abort', error); + } + if (error instanceof AnthropicError) { + return this._emit('error', error); + } + if (error instanceof Error) { + const anthropicError: AnthropicError = new AnthropicError(error.message); + // @ts-ignore + anthropicError.cause = error; + return this._emit('error', anthropicError); + } + return this._emit('error', new AnthropicError(String(error))); + }; + + protected _emit( + event: Event, + ...args: Parameters + ) { + // make sure we don't emit any MessageStreamEvents after end + if (this.#ended) return; + + if (event === 'end') { + this.#ended = true; + this.#resolveEndPromise(); + } + + const listeners: MessageStreamEventListeners | undefined = this.#listeners[event]; + if (listeners) { + this.#listeners[event] = listeners.filter((l) => !l.once) as any; + listeners.forEach(({ listener }: any) => listener(...args)); + } + + if (event === 'abort') { + const error = args[0] as APIUserAbortError; + if (!this.#catchingPromiseCreated && !listeners?.length) { + Promise.reject(error); + } + this.#rejectConnectedPromise(error); + this.#rejectEndPromise(error); + this._emit('end'); + return; + } + + if (event === 'error') { + // NOTE: _emit('error', error) should only be called from #handleError(). + + const error = args[0] as AnthropicError; + if (!this.#catchingPromiseCreated && !listeners?.length) { + // Trigger an unhandled rejection if the user hasn't registered any error handlers. + // If you are seeing stack traces here, make sure to handle errors via either: + // - runner.on('error', () => ...) + // - await runner.done() + // - await runner.final...() + // - etc. + Promise.reject(error); + } + this.#rejectConnectedPromise(error); + this.#rejectEndPromise(error); + this._emit('end'); + } + } + + protected _emitFinal() { + const finalMessage = this.receivedMessages.at(-1); + if (finalMessage) { + this._emit('finalMessage', this.#getFinalMessage()); + } + } + + #beginRequest() { + if (this.ended) return; + this.#currentMessageSnapshot = undefined; + } + #addStreamEvent(event: BetaMessageStreamEvent) { + if (this.ended) return; + const messageSnapshot = this.#accumulateMessage(event); + this._emit('streamEvent', event, messageSnapshot); + + switch (event.type) { + case 'content_block_delta': { + const content = messageSnapshot.content.at(-1)!; + switch (event.delta.type) { + case 'text_delta': { + if (content.type === 'text') { + this._emit('text', event.delta.text, content.text || ''); + } + break; + } + case 'citations_delta': { + if (content.type === 'text') { + this._emit('citation', event.delta.citation, content.citations ?? []); + } + break; + } + case 'input_json_delta': { + if (tracksToolInput(content) && content.input) { + this._emit('inputJson', event.delta.partial_json, content.input); + } + break; + } + case 'thinking_delta': { + if (content.type === 'thinking') { + this._emit('thinking', event.delta.thinking, content.thinking); + } + break; + } + case 'signature_delta': { + if (content.type === 'thinking') { + this._emit('signature', content.signature); + } + break; + } + default: + checkNever(event.delta); + } + break; + } + case 'message_stop': { + this._addMessageParam(messageSnapshot); + this._addMessage(messageSnapshot, true); + break; + } + case 'content_block_stop': { + this._emit('contentBlock', messageSnapshot.content.at(-1)!); + break; + } + case 'message_start': { + this.#currentMessageSnapshot = messageSnapshot; + break; + } + case 'content_block_start': + case 'message_delta': + break; + } + } + #endRequest(): BetaMessage { + if (this.ended) { + throw new AnthropicError(`stream has ended, this shouldn't happen`); + } + const snapshot = this.#currentMessageSnapshot; + if (!snapshot) { + throw new AnthropicError(`request ended without sending any chunks`); + } + this.#currentMessageSnapshot = undefined; + return snapshot; + } + + protected async _fromReadableStream( + readableStream: ReadableStream, + options?: RequestOptions, + ): Promise { + const signal = options?.signal; + let abortHandler: (() => void) | undefined; + if (signal) { + if (signal.aborted) this.controller.abort(); + abortHandler = this.controller.abort.bind(this.controller); + signal.addEventListener('abort', abortHandler); + } + try { + this.#beginRequest(); + this._connected(null); + const stream = Stream.fromReadableStream(readableStream, this.controller); + for await (const event of stream) { + this.#addStreamEvent(event); + } + if (stream.controller.signal?.aborted) { + throw new APIUserAbortError(); + } + this.#endRequest(); + } finally { + if (signal && abortHandler) { + signal.removeEventListener('abort', abortHandler); + } + } + } + + /** + * Mutates this.#currentMessage with the current event. Handling the accumulation of multiple messages + * will be needed to be handled by the caller, this method will throw if you try to accumulate for multiple + * messages. + */ + #accumulateMessage(event: BetaMessageStreamEvent): BetaMessage { + let snapshot = this.#currentMessageSnapshot; + + if (event.type === 'message_start') { + if (snapshot) { + throw new AnthropicError(`Unexpected event order, got ${event.type} before receiving "message_stop"`); + } + return event.message; + } + + if (!snapshot) { + throw new AnthropicError(`Unexpected event order, got ${event.type} before "message_start"`); + } + + switch (event.type) { + case 'message_stop': + return snapshot; + case 'message_delta': + snapshot.container = event.delta.container; + snapshot.stop_reason = event.delta.stop_reason; + snapshot.stop_sequence = event.delta.stop_sequence; + snapshot.usage.output_tokens = event.usage.output_tokens; + + if (event.usage.input_tokens != null) { + snapshot.usage.input_tokens = event.usage.input_tokens; + } + + if (event.usage.cache_creation_input_tokens != null) { + snapshot.usage.cache_creation_input_tokens = event.usage.cache_creation_input_tokens; + } + + if (event.usage.cache_read_input_tokens != null) { + snapshot.usage.cache_read_input_tokens = event.usage.cache_read_input_tokens; + } + + if (event.usage.server_tool_use != null) { + snapshot.usage.server_tool_use = event.usage.server_tool_use; + } + + return snapshot; + case 'content_block_start': + snapshot.content.push(event.content_block); + return snapshot; + case 'content_block_delta': { + const snapshotContent = snapshot.content.at(event.index); + + switch (event.delta.type) { + case 'text_delta': { + if (snapshotContent?.type === 'text') { + snapshot.content[event.index] = { + ...snapshotContent, + text: (snapshotContent.text || '') + event.delta.text, + }; + } + break; + } + case 'citations_delta': { + if (snapshotContent?.type === 'text') { + snapshot.content[event.index] = { + ...snapshotContent, + citations: [...(snapshotContent.citations ?? []), event.delta.citation], + }; + } + break; + } + case 'input_json_delta': { + if (snapshotContent && tracksToolInput(snapshotContent)) { + // we need to keep track of the raw JSON string as well so that we can + // re-parse it for each delta, for now we just store it as an untyped + // non-enumerable property on the snapshot + let jsonBuf = (snapshotContent as any)[JSON_BUF_PROPERTY] || ''; + jsonBuf += event.delta.partial_json; + + const newContent = { ...snapshotContent }; + Object.defineProperty(newContent, JSON_BUF_PROPERTY, { + value: jsonBuf, + enumerable: false, + writable: true, + }); + + if (jsonBuf) { + try { + newContent.input = partialParse(jsonBuf); + } catch (err) { + const error = new AnthropicError( + `Unable to parse tool parameter JSON from model. Please retry your request or adjust your prompt. Error: ${err}. JSON: ${jsonBuf}`, + ); + this.#handleError(error); + } + } + snapshot.content[event.index] = newContent; + } + break; + } + case 'thinking_delta': { + if (snapshotContent?.type === 'thinking') { + snapshot.content[event.index] = { + ...snapshotContent, + thinking: snapshotContent.thinking + event.delta.thinking, + }; + } + break; + } + case 'signature_delta': { + if (snapshotContent?.type === 'thinking') { + snapshot.content[event.index] = { + ...snapshotContent, + signature: event.delta.signature, + }; + } + break; + } + default: + checkNever(event.delta); + } + return snapshot; + } + case 'content_block_stop': + return snapshot; + } + } + + [Symbol.asyncIterator](): AsyncIterator { + const pushQueue: BetaMessageStreamEvent[] = []; + const readQueue: { + resolve: (chunk: BetaMessageStreamEvent | undefined) => void; + reject: (error: unknown) => void; + }[] = []; + let done = false; + + this.on('streamEvent', (event) => { + const reader = readQueue.shift(); + if (reader) { + reader.resolve(event); + } else { + pushQueue.push(event); + } + }); + + this.on('end', () => { + done = true; + for (const reader of readQueue) { + reader.resolve(undefined); + } + readQueue.length = 0; + }); + + this.on('abort', (err) => { + done = true; + for (const reader of readQueue) { + reader.reject(err); + } + readQueue.length = 0; + }); + + this.on('error', (err) => { + done = true; + for (const reader of readQueue) { + reader.reject(err); + } + readQueue.length = 0; + }); + + return { + next: async (): Promise> => { + if (!pushQueue.length) { + if (done) { + return { value: undefined, done: true }; + } + return new Promise((resolve, reject) => + readQueue.push({ resolve, reject }), + ).then((chunk) => (chunk ? { value: chunk, done: false } : { value: undefined, done: true })); + } + const chunk = pushQueue.shift()!; + return { value: chunk, done: false }; + }, + return: async () => { + this.abort(); + return { value: undefined, done: true }; + }, + }; + } + + toReadableStream(): ReadableStream { + const stream = new Stream(this[Symbol.asyncIterator].bind(this), this.controller); + return stream.toReadableStream(); + } +} + +// used to ensure exhaustive case matching without throwing a runtime error +function checkNever(x: never) {} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/lib/MessageStream.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/lib/MessageStream.ts new file mode 100644 index 0000000000000000000000000000000000000000..3ad3bedfdc53daed3816b6d32f62f88ece9fa863 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/lib/MessageStream.ts @@ -0,0 +1,720 @@ +import { isAbortError } from '../internal/errors'; +import { AnthropicError, APIUserAbortError } from '../error'; +import { + type ContentBlock, + Messages, + type Message, + type MessageStreamEvent, + type MessageParam, + type MessageCreateParams, + type MessageCreateParamsBase, + type TextBlock, + type TextCitation, + type ToolUseBlock, + type ServerToolUseBlock, +} from '../resources/messages'; +import { Stream } from '../streaming'; +import { partialParse } from '../_vendor/partial-json-parser/parser'; +import { RequestOptions } from '../internal/request-options'; + +export interface MessageStreamEvents { + connect: () => void; + streamEvent: (event: MessageStreamEvent, snapshot: Message) => void; + text: (textDelta: string, textSnapshot: string) => void; + citation: (citation: TextCitation, citationsSnapshot: TextCitation[]) => void; + inputJson: (partialJson: string, jsonSnapshot: unknown) => void; + thinking: (thinkingDelta: string, thinkingSnapshot: string) => void; + signature: (signature: string) => void; + message: (message: Message) => void; + contentBlock: (content: ContentBlock) => void; + finalMessage: (message: Message) => void; + error: (error: AnthropicError) => void; + abort: (error: APIUserAbortError) => void; + end: () => void; +} + +type MessageStreamEventListeners = { + listener: MessageStreamEvents[Event]; + once?: boolean; +}[]; + +const JSON_BUF_PROPERTY = '__json_buf'; + +export type TracksToolInput = ToolUseBlock | ServerToolUseBlock; + +function tracksToolInput(content: ContentBlock): content is TracksToolInput { + return content.type === 'tool_use' || content.type === 'server_tool_use'; +} + +export class MessageStream implements AsyncIterable { + messages: MessageParam[] = []; + receivedMessages: Message[] = []; + #currentMessageSnapshot: Message | undefined; + + controller: AbortController = new AbortController(); + + #connectedPromise: Promise; + #resolveConnectedPromise: (response: Response | null) => void = () => {}; + #rejectConnectedPromise: (error: AnthropicError) => void = () => {}; + + #endPromise: Promise; + #resolveEndPromise: () => void = () => {}; + #rejectEndPromise: (error: AnthropicError) => void = () => {}; + + #listeners: { [Event in keyof MessageStreamEvents]?: MessageStreamEventListeners } = {}; + + #ended = false; + #errored = false; + #aborted = false; + #catchingPromiseCreated = false; + #response: Response | null | undefined; + #request_id: string | null | undefined; + + constructor() { + this.#connectedPromise = new Promise((resolve, reject) => { + this.#resolveConnectedPromise = resolve; + this.#rejectConnectedPromise = reject; + }); + + this.#endPromise = new Promise((resolve, reject) => { + this.#resolveEndPromise = resolve; + this.#rejectEndPromise = reject; + }); + + // Don't let these promises cause unhandled rejection errors. + // we will manually cause an unhandled rejection error later + // if the user hasn't registered any error listener or called + // any promise-returning method. + this.#connectedPromise.catch(() => {}); + this.#endPromise.catch(() => {}); + } + + get response(): Response | null | undefined { + return this.#response; + } + + get request_id(): string | null | undefined { + return this.#request_id; + } + + /** + * Returns the `MessageStream` data, the raw `Response` instance and the ID of the request, + * returned vie the `request-id` header which is useful for debugging requests and resporting + * issues to Anthropic. + * + * This is the same as the `APIPromise.withResponse()` method. + * + * This method will raise an error if you created the stream using `MessageStream.fromReadableStream` + * as no `Response` is available. + */ + async withResponse(): Promise<{ + data: MessageStream; + response: Response; + request_id: string | null | undefined; + }> { + const response = await this.#connectedPromise; + if (!response) { + throw new Error('Could not resolve a `Response` object'); + } + + return { + data: this, + response, + request_id: response.headers.get('request-id'), + }; + } + + /** + * Intended for use on the frontend, consuming a stream produced with + * `.toReadableStream()` on the backend. + * + * Note that messages sent to the model do not appear in `.on('message')` + * in this context. + */ + static fromReadableStream(stream: ReadableStream): MessageStream { + const runner = new MessageStream(); + runner._run(() => runner._fromReadableStream(stream)); + return runner; + } + + static createMessage( + messages: Messages, + params: MessageCreateParamsBase, + options?: RequestOptions, + ): MessageStream { + const runner = new MessageStream(); + for (const message of params.messages) { + runner._addMessageParam(message); + } + runner._run(() => + runner._createMessage( + messages, + { ...params, stream: true }, + { ...options, headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'stream' } }, + ), + ); + return runner; + } + + protected _run(executor: () => Promise) { + executor().then(() => { + this._emitFinal(); + this._emit('end'); + }, this.#handleError); + } + + protected _addMessageParam(message: MessageParam) { + this.messages.push(message); + } + + protected _addMessage(message: Message, emit = true) { + this.receivedMessages.push(message); + if (emit) { + this._emit('message', message); + } + } + + protected async _createMessage( + messages: Messages, + params: MessageCreateParams, + options?: RequestOptions, + ): Promise { + const signal = options?.signal; + let abortHandler: (() => void) | undefined; + if (signal) { + if (signal.aborted) this.controller.abort(); + abortHandler = this.controller.abort.bind(this.controller); + signal.addEventListener('abort', abortHandler); + } + try { + this.#beginRequest(); + const { response, data: stream } = await messages + .create({ ...params, stream: true }, { ...options, signal: this.controller.signal }) + .withResponse(); + this._connected(response); + for await (const event of stream) { + this.#addStreamEvent(event); + } + if (stream.controller.signal?.aborted) { + throw new APIUserAbortError(); + } + this.#endRequest(); + } finally { + if (signal && abortHandler) { + signal.removeEventListener('abort', abortHandler); + } + } + } + + protected _connected(response: Response | null) { + if (this.ended) return; + this.#response = response; + this.#request_id = response?.headers.get('request-id'); + this.#resolveConnectedPromise(response); + this._emit('connect'); + } + + get ended(): boolean { + return this.#ended; + } + + get errored(): boolean { + return this.#errored; + } + + get aborted(): boolean { + return this.#aborted; + } + + abort() { + this.controller.abort(); + } + + /** + * Adds the listener function to the end of the listeners array for the event. + * No checks are made to see if the listener has already been added. Multiple calls passing + * the same combination of event and listener will result in the listener being added, and + * called, multiple times. + * @returns this MessageStream, so that calls can be chained + */ + on(event: Event, listener: MessageStreamEvents[Event]): this { + const listeners: MessageStreamEventListeners = + this.#listeners[event] || (this.#listeners[event] = []); + listeners.push({ listener }); + return this; + } + + /** + * Removes the specified listener from the listener array for the event. + * off() will remove, at most, one instance of a listener from the listener array. If any single + * listener has been added multiple times to the listener array for the specified event, then + * off() must be called multiple times to remove each instance. + * @returns this MessageStream, so that calls can be chained + */ + off(event: Event, listener: MessageStreamEvents[Event]): this { + const listeners = this.#listeners[event]; + if (!listeners) return this; + const index = listeners.findIndex((l) => l.listener === listener); + if (index >= 0) listeners.splice(index, 1); + return this; + } + + /** + * Adds a one-time listener function for the event. The next time the event is triggered, + * this listener is removed and then invoked. + * @returns this MessageStream, so that calls can be chained + */ + once(event: Event, listener: MessageStreamEvents[Event]): this { + const listeners: MessageStreamEventListeners = + this.#listeners[event] || (this.#listeners[event] = []); + listeners.push({ listener, once: true }); + return this; + } + + /** + * This is similar to `.once()`, but returns a Promise that resolves the next time + * the event is triggered, instead of calling a listener callback. + * @returns a Promise that resolves the next time given event is triggered, + * or rejects if an error is emitted. (If you request the 'error' event, + * returns a promise that resolves with the error). + * + * Example: + * + * const message = await stream.emitted('message') // rejects if the stream errors + */ + emitted( + event: Event, + ): Promise< + Parameters extends [infer Param] ? Param + : Parameters extends [] ? void + : Parameters + > { + return new Promise((resolve, reject) => { + this.#catchingPromiseCreated = true; + if (event !== 'error') this.once('error', reject); + this.once(event, resolve as any); + }); + } + + async done(): Promise { + this.#catchingPromiseCreated = true; + await this.#endPromise; + } + + get currentMessage(): Message | undefined { + return this.#currentMessageSnapshot; + } + + #getFinalMessage(): Message { + if (this.receivedMessages.length === 0) { + throw new AnthropicError('stream ended without producing a Message with role=assistant'); + } + return this.receivedMessages.at(-1)!; + } + + /** + * @returns a promise that resolves with the the final assistant Message response, + * or rejects if an error occurred or the stream ended prematurely without producing a Message. + */ + async finalMessage(): Promise { + await this.done(); + return this.#getFinalMessage(); + } + + #getFinalText(): string { + if (this.receivedMessages.length === 0) { + throw new AnthropicError('stream ended without producing a Message with role=assistant'); + } + const textBlocks = this.receivedMessages + .at(-1)! + .content.filter((block): block is TextBlock => block.type === 'text') + .map((block) => block.text); + if (textBlocks.length === 0) { + throw new AnthropicError('stream ended without producing a content block with type=text'); + } + return textBlocks.join(' '); + } + + /** + * @returns a promise that resolves with the the final assistant Message's text response, concatenated + * together if there are more than one text blocks. + * Rejects if an error occurred or the stream ended prematurely without producing a Message. + */ + async finalText(): Promise { + await this.done(); + return this.#getFinalText(); + } + + #handleError = (error: unknown) => { + this.#errored = true; + if (isAbortError(error)) { + error = new APIUserAbortError(); + } + if (error instanceof APIUserAbortError) { + this.#aborted = true; + return this._emit('abort', error); + } + if (error instanceof AnthropicError) { + return this._emit('error', error); + } + if (error instanceof Error) { + const anthropicError: AnthropicError = new AnthropicError(error.message); + // @ts-ignore + anthropicError.cause = error; + return this._emit('error', anthropicError); + } + return this._emit('error', new AnthropicError(String(error))); + }; + + protected _emit( + event: Event, + ...args: Parameters + ) { + // make sure we don't emit any MessageStreamEvents after end + if (this.#ended) return; + + if (event === 'end') { + this.#ended = true; + this.#resolveEndPromise(); + } + + const listeners: MessageStreamEventListeners | undefined = this.#listeners[event]; + if (listeners) { + this.#listeners[event] = listeners.filter((l) => !l.once) as any; + listeners.forEach(({ listener }: any) => listener(...args)); + } + + if (event === 'abort') { + const error = args[0] as APIUserAbortError; + if (!this.#catchingPromiseCreated && !listeners?.length) { + Promise.reject(error); + } + this.#rejectConnectedPromise(error); + this.#rejectEndPromise(error); + this._emit('end'); + return; + } + + if (event === 'error') { + // NOTE: _emit('error', error) should only be called from #handleError(). + + const error = args[0] as AnthropicError; + if (!this.#catchingPromiseCreated && !listeners?.length) { + // Trigger an unhandled rejection if the user hasn't registered any error handlers. + // If you are seeing stack traces here, make sure to handle errors via either: + // - runner.on('error', () => ...) + // - await runner.done() + // - await runner.final...() + // - etc. + Promise.reject(error); + } + this.#rejectConnectedPromise(error); + this.#rejectEndPromise(error); + this._emit('end'); + } + } + + protected _emitFinal() { + const finalMessage = this.receivedMessages.at(-1); + if (finalMessage) { + this._emit('finalMessage', this.#getFinalMessage()); + } + } + + #beginRequest() { + if (this.ended) return; + this.#currentMessageSnapshot = undefined; + } + #addStreamEvent(event: MessageStreamEvent) { + if (this.ended) return; + const messageSnapshot = this.#accumulateMessage(event); + this._emit('streamEvent', event, messageSnapshot); + + switch (event.type) { + case 'content_block_delta': { + const content = messageSnapshot.content.at(-1)!; + switch (event.delta.type) { + case 'text_delta': { + if (content.type === 'text') { + this._emit('text', event.delta.text, content.text || ''); + } + break; + } + case 'citations_delta': { + if (content.type === 'text') { + this._emit('citation', event.delta.citation, content.citations ?? []); + } + break; + } + case 'input_json_delta': { + if (tracksToolInput(content) && content.input) { + this._emit('inputJson', event.delta.partial_json, content.input); + } + break; + } + case 'thinking_delta': { + if (content.type === 'thinking') { + this._emit('thinking', event.delta.thinking, content.thinking); + } + break; + } + case 'signature_delta': { + if (content.type === 'thinking') { + this._emit('signature', content.signature); + } + break; + } + default: + checkNever(event.delta); + } + break; + } + case 'message_stop': { + this._addMessageParam(messageSnapshot); + this._addMessage(messageSnapshot, true); + break; + } + case 'content_block_stop': { + this._emit('contentBlock', messageSnapshot.content.at(-1)!); + break; + } + case 'message_start': { + this.#currentMessageSnapshot = messageSnapshot; + break; + } + case 'content_block_start': + case 'message_delta': + break; + } + } + #endRequest(): Message { + if (this.ended) { + throw new AnthropicError(`stream has ended, this shouldn't happen`); + } + const snapshot = this.#currentMessageSnapshot; + if (!snapshot) { + throw new AnthropicError(`request ended without sending any chunks`); + } + this.#currentMessageSnapshot = undefined; + return snapshot; + } + + protected async _fromReadableStream( + readableStream: ReadableStream, + options?: RequestOptions, + ): Promise { + const signal = options?.signal; + let abortHandler: (() => void) | undefined; + if (signal) { + if (signal.aborted) this.controller.abort(); + abortHandler = this.controller.abort.bind(this.controller); + signal.addEventListener('abort', abortHandler); + } + try { + this.#beginRequest(); + this._connected(null); + const stream = Stream.fromReadableStream(readableStream, this.controller); + for await (const event of stream) { + this.#addStreamEvent(event); + } + if (stream.controller.signal?.aborted) { + throw new APIUserAbortError(); + } + this.#endRequest(); + } finally { + if (signal && abortHandler) { + signal.removeEventListener('abort', abortHandler); + } + } + } + + /** + * Mutates this.#currentMessage with the current event. Handling the accumulation of multiple messages + * will be needed to be handled by the caller, this method will throw if you try to accumulate for multiple + * messages. + */ + #accumulateMessage(event: MessageStreamEvent): Message { + let snapshot = this.#currentMessageSnapshot; + + if (event.type === 'message_start') { + if (snapshot) { + throw new AnthropicError(`Unexpected event order, got ${event.type} before receiving "message_stop"`); + } + return event.message; + } + + if (!snapshot) { + throw new AnthropicError(`Unexpected event order, got ${event.type} before "message_start"`); + } + + switch (event.type) { + case 'message_stop': + return snapshot; + case 'message_delta': + snapshot.stop_reason = event.delta.stop_reason; + snapshot.stop_sequence = event.delta.stop_sequence; + snapshot.usage.output_tokens = event.usage.output_tokens; + + // Update other usage fields if they exist in the event + if (event.usage.input_tokens != null) { + snapshot.usage.input_tokens = event.usage.input_tokens; + } + + if (event.usage.cache_creation_input_tokens != null) { + snapshot.usage.cache_creation_input_tokens = event.usage.cache_creation_input_tokens; + } + + if (event.usage.cache_read_input_tokens != null) { + snapshot.usage.cache_read_input_tokens = event.usage.cache_read_input_tokens; + } + + if (event.usage.server_tool_use != null) { + snapshot.usage.server_tool_use = event.usage.server_tool_use; + } + + return snapshot; + case 'content_block_start': + snapshot.content.push({ ...event.content_block }); + return snapshot; + case 'content_block_delta': { + const snapshotContent = snapshot.content.at(event.index); + + switch (event.delta.type) { + case 'text_delta': { + if (snapshotContent?.type === 'text') { + snapshot.content[event.index] = { + ...snapshotContent, + text: (snapshotContent.text || '') + event.delta.text, + }; + } + break; + } + case 'citations_delta': { + if (snapshotContent?.type === 'text') { + snapshot.content[event.index] = { + ...snapshotContent, + citations: [...(snapshotContent.citations ?? []), event.delta.citation], + }; + } + break; + } + case 'input_json_delta': { + if (snapshotContent && tracksToolInput(snapshotContent)) { + // we need to keep track of the raw JSON string as well so that we can + // re-parse it for each delta, for now we just store it as an untyped + // non-enumerable property on the snapshot + let jsonBuf = (snapshotContent as any)[JSON_BUF_PROPERTY] || ''; + jsonBuf += event.delta.partial_json; + + const newContent = { ...snapshotContent }; + Object.defineProperty(newContent, JSON_BUF_PROPERTY, { + value: jsonBuf, + enumerable: false, + writable: true, + }); + + if (jsonBuf) { + newContent.input = partialParse(jsonBuf); + } + snapshot.content[event.index] = newContent; + } + break; + } + case 'thinking_delta': { + if (snapshotContent?.type === 'thinking') { + snapshot.content[event.index] = { + ...snapshotContent, + thinking: snapshotContent.thinking + event.delta.thinking, + }; + } + break; + } + case 'signature_delta': { + if (snapshotContent?.type === 'thinking') { + snapshot.content[event.index] = { + ...snapshotContent, + signature: event.delta.signature, + }; + } + break; + } + default: + checkNever(event.delta); + } + + return snapshot; + } + case 'content_block_stop': + return snapshot; + } + } + + [Symbol.asyncIterator](): AsyncIterator { + const pushQueue: MessageStreamEvent[] = []; + const readQueue: { + resolve: (chunk: MessageStreamEvent | undefined) => void; + reject: (error: unknown) => void; + }[] = []; + let done = false; + + this.on('streamEvent', (event) => { + const reader = readQueue.shift(); + if (reader) { + reader.resolve(event); + } else { + pushQueue.push(event); + } + }); + + this.on('end', () => { + done = true; + for (const reader of readQueue) { + reader.resolve(undefined); + } + readQueue.length = 0; + }); + + this.on('abort', (err) => { + done = true; + for (const reader of readQueue) { + reader.reject(err); + } + readQueue.length = 0; + }); + + this.on('error', (err) => { + done = true; + for (const reader of readQueue) { + reader.reject(err); + } + readQueue.length = 0; + }); + + return { + next: async (): Promise> => { + if (!pushQueue.length) { + if (done) { + return { value: undefined, done: true }; + } + return new Promise((resolve, reject) => + readQueue.push({ resolve, reject }), + ).then((chunk) => (chunk ? { value: chunk, done: false } : { value: undefined, done: true })); + } + const chunk = pushQueue.shift()!; + return { value: chunk, done: false }; + }, + return: async () => { + this.abort(); + return { value: undefined, done: true }; + }, + }; + } + + toReadableStream(): ReadableStream { + const stream = new Stream(this[Symbol.asyncIterator].bind(this), this.controller); + return stream.toReadableStream(); + } +} + +// used to ensure exhaustive case matching without throwing a runtime error +function checkNever(x: never) {} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/pagination.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/pagination.ts new file mode 100644 index 0000000000000000000000000000000000000000..90bf015e124ad08b8f3a5fa818f0ab115d8e72f6 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/pagination.ts @@ -0,0 +1,2 @@ +/** @deprecated Import from ./core/pagination instead */ +export * from './core/pagination'; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resource.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resource.ts new file mode 100644 index 0000000000000000000000000000000000000000..363e3516b1499158e04fab6c25c747f9c01f3a99 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resource.ts @@ -0,0 +1,2 @@ +/** @deprecated Import from ./core/resource instead */ +export * from './core/resource'; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources.ts new file mode 100644 index 0000000000000000000000000000000000000000..b283d5781de54a4df740f51ff11277e0787cb714 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources.ts @@ -0,0 +1 @@ +export * from './resources/index'; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta.ts new file mode 100644 index 0000000000000000000000000000000000000000..1542e942b513d490a80ef1a063f8f7221de8b0c1 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta.ts @@ -0,0 +1,3 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +export * from './beta/index'; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/beta.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/beta.ts new file mode 100644 index 0000000000000000000000000000000000000000..b95da398b4fecc7f3a2a01bfef1b1b339798a90a --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/beta.ts @@ -0,0 +1,388 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import { APIResource } from '../../core/resource'; +import * as FilesAPI from './files'; +import { + DeletedFile, + FileDeleteParams, + FileDownloadParams, + FileListParams, + FileMetadata, + FileMetadataPage, + FileRetrieveMetadataParams, + FileUploadParams, + Files, +} from './files'; +import * as ModelsAPI from './models'; +import { BetaModelInfo, BetaModelInfosPage, ModelListParams, ModelRetrieveParams, Models } from './models'; +import * as MessagesAPI from './messages/messages'; +import { + BetaBase64ImageSource, + BetaBase64PDFBlock, + BetaBase64PDFSource, + BetaCacheControlEphemeral, + BetaCacheCreation, + BetaCitationCharLocation, + BetaCitationCharLocationParam, + BetaCitationContentBlockLocation, + BetaCitationContentBlockLocationParam, + BetaCitationPageLocation, + BetaCitationPageLocationParam, + BetaCitationSearchResultLocation, + BetaCitationSearchResultLocationParam, + BetaCitationWebSearchResultLocationParam, + BetaCitationsConfigParam, + BetaCitationsDelta, + BetaCitationsWebSearchResultLocation, + BetaCodeExecutionOutputBlock, + BetaCodeExecutionOutputBlockParam, + BetaCodeExecutionResultBlock, + BetaCodeExecutionResultBlockParam, + BetaCodeExecutionTool20250522, + BetaCodeExecutionToolResultBlock, + BetaCodeExecutionToolResultBlockContent, + BetaCodeExecutionToolResultBlockParam, + BetaCodeExecutionToolResultBlockParamContent, + BetaCodeExecutionToolResultError, + BetaCodeExecutionToolResultErrorCode, + BetaCodeExecutionToolResultErrorParam, + BetaContainer, + BetaContainerUploadBlock, + BetaContainerUploadBlockParam, + BetaContentBlock, + BetaContentBlockParam, + BetaContentBlockSource, + BetaContentBlockSourceContent, + BetaFileDocumentSource, + BetaFileImageSource, + BetaImageBlockParam, + BetaInputJSONDelta, + BetaMCPToolResultBlock, + BetaMCPToolUseBlock, + BetaMCPToolUseBlockParam, + BetaMessage, + BetaMessageDeltaUsage, + BetaMessageParam, + BetaMessageTokensCount, + BetaMetadata, + BetaPlainTextSource, + BetaRawContentBlockDelta, + BetaRawContentBlockDeltaEvent, + BetaRawContentBlockStartEvent, + BetaRawContentBlockStopEvent, + BetaRawMessageDeltaEvent, + BetaRawMessageStartEvent, + BetaRawMessageStopEvent, + BetaRawMessageStreamEvent, + BetaRedactedThinkingBlock, + BetaRedactedThinkingBlockParam, + BetaRequestDocumentBlock, + BetaRequestMCPServerToolConfiguration, + BetaRequestMCPServerURLDefinition, + BetaRequestMCPToolResultBlockParam, + BetaSearchResultBlockParam, + BetaServerToolUsage, + BetaServerToolUseBlock, + BetaServerToolUseBlockParam, + BetaSignatureDelta, + BetaStopReason, + BetaTextBlock, + BetaTextBlockParam, + BetaTextCitation, + BetaTextCitationParam, + BetaTextDelta, + BetaThinkingBlock, + BetaThinkingBlockParam, + BetaThinkingConfigDisabled, + BetaThinkingConfigEnabled, + BetaThinkingConfigParam, + BetaThinkingDelta, + BetaTool, + BetaToolBash20241022, + BetaToolBash20250124, + BetaToolChoice, + BetaToolChoiceAny, + BetaToolChoiceAuto, + BetaToolChoiceNone, + BetaToolChoiceTool, + BetaToolComputerUse20241022, + BetaToolComputerUse20250124, + BetaToolResultBlockParam, + BetaToolTextEditor20241022, + BetaToolTextEditor20250124, + BetaToolTextEditor20250429, + BetaToolUnion, + BetaToolUseBlock, + BetaToolUseBlockParam, + BetaURLImageSource, + BetaURLPDFSource, + BetaUsage, + BetaWebSearchResultBlock, + BetaWebSearchResultBlockParam, + BetaWebSearchTool20250305, + BetaWebSearchToolRequestError, + BetaWebSearchToolResultBlock, + BetaWebSearchToolResultBlockContent, + BetaWebSearchToolResultBlockParam, + BetaWebSearchToolResultBlockParamContent, + BetaWebSearchToolResultError, + BetaWebSearchToolResultErrorCode, + MessageCountTokensParams, + MessageCreateParams, + MessageCreateParamsNonStreaming, + MessageCreateParamsStreaming, + Messages, +} from './messages/messages'; + +export class Beta extends APIResource { + models: ModelsAPI.Models = new ModelsAPI.Models(this._client); + messages: MessagesAPI.Messages = new MessagesAPI.Messages(this._client); + files: FilesAPI.Files = new FilesAPI.Files(this._client); +} + +export type AnthropicBeta = + | (string & {}) + | 'message-batches-2024-09-24' + | 'prompt-caching-2024-07-31' + | 'computer-use-2024-10-22' + | 'computer-use-2025-01-24' + | 'pdfs-2024-09-25' + | 'token-counting-2024-11-01' + | 'token-efficient-tools-2025-02-19' + | 'output-128k-2025-02-19' + | 'files-api-2025-04-14' + | 'mcp-client-2025-04-04' + | 'dev-full-thinking-2025-05-14' + | 'interleaved-thinking-2025-05-14' + | 'code-execution-2025-05-22' + | 'extended-cache-ttl-2025-04-11'; + +export interface BetaAPIError { + message: string; + + type: 'api_error'; +} + +export interface BetaAuthenticationError { + message: string; + + type: 'authentication_error'; +} + +export interface BetaBillingError { + message: string; + + type: 'billing_error'; +} + +export type BetaError = + | BetaInvalidRequestError + | BetaAuthenticationError + | BetaBillingError + | BetaPermissionError + | BetaNotFoundError + | BetaRateLimitError + | BetaGatewayTimeoutError + | BetaAPIError + | BetaOverloadedError; + +export interface BetaErrorResponse { + error: BetaError; + + type: 'error'; +} + +export interface BetaGatewayTimeoutError { + message: string; + + type: 'timeout_error'; +} + +export interface BetaInvalidRequestError { + message: string; + + type: 'invalid_request_error'; +} + +export interface BetaNotFoundError { + message: string; + + type: 'not_found_error'; +} + +export interface BetaOverloadedError { + message: string; + + type: 'overloaded_error'; +} + +export interface BetaPermissionError { + message: string; + + type: 'permission_error'; +} + +export interface BetaRateLimitError { + message: string; + + type: 'rate_limit_error'; +} + +Beta.Models = Models; +Beta.Messages = Messages; +Beta.Files = Files; + +export declare namespace Beta { + export { + type AnthropicBeta as AnthropicBeta, + type BetaAPIError as BetaAPIError, + type BetaAuthenticationError as BetaAuthenticationError, + type BetaBillingError as BetaBillingError, + type BetaError as BetaError, + type BetaErrorResponse as BetaErrorResponse, + type BetaGatewayTimeoutError as BetaGatewayTimeoutError, + type BetaInvalidRequestError as BetaInvalidRequestError, + type BetaNotFoundError as BetaNotFoundError, + type BetaOverloadedError as BetaOverloadedError, + type BetaPermissionError as BetaPermissionError, + type BetaRateLimitError as BetaRateLimitError, + }; + + export { + Models as Models, + type BetaModelInfo as BetaModelInfo, + type BetaModelInfosPage as BetaModelInfosPage, + type ModelRetrieveParams as ModelRetrieveParams, + type ModelListParams as ModelListParams, + }; + + export { + Messages as Messages, + type BetaBase64ImageSource as BetaBase64ImageSource, + type BetaBase64PDFSource as BetaBase64PDFSource, + type BetaCacheControlEphemeral as BetaCacheControlEphemeral, + type BetaCacheCreation as BetaCacheCreation, + type BetaCitationCharLocation as BetaCitationCharLocation, + type BetaCitationCharLocationParam as BetaCitationCharLocationParam, + type BetaCitationContentBlockLocation as BetaCitationContentBlockLocation, + type BetaCitationContentBlockLocationParam as BetaCitationContentBlockLocationParam, + type BetaCitationPageLocation as BetaCitationPageLocation, + type BetaCitationPageLocationParam as BetaCitationPageLocationParam, + type BetaCitationSearchResultLocation as BetaCitationSearchResultLocation, + type BetaCitationSearchResultLocationParam as BetaCitationSearchResultLocationParam, + type BetaCitationWebSearchResultLocationParam as BetaCitationWebSearchResultLocationParam, + type BetaCitationsConfigParam as BetaCitationsConfigParam, + type BetaCitationsDelta as BetaCitationsDelta, + type BetaCitationsWebSearchResultLocation as BetaCitationsWebSearchResultLocation, + type BetaCodeExecutionOutputBlock as BetaCodeExecutionOutputBlock, + type BetaCodeExecutionOutputBlockParam as BetaCodeExecutionOutputBlockParam, + type BetaCodeExecutionResultBlock as BetaCodeExecutionResultBlock, + type BetaCodeExecutionResultBlockParam as BetaCodeExecutionResultBlockParam, + type BetaCodeExecutionTool20250522 as BetaCodeExecutionTool20250522, + type BetaCodeExecutionToolResultBlock as BetaCodeExecutionToolResultBlock, + type BetaCodeExecutionToolResultBlockContent as BetaCodeExecutionToolResultBlockContent, + type BetaCodeExecutionToolResultBlockParam as BetaCodeExecutionToolResultBlockParam, + type BetaCodeExecutionToolResultBlockParamContent as BetaCodeExecutionToolResultBlockParamContent, + type BetaCodeExecutionToolResultError as BetaCodeExecutionToolResultError, + type BetaCodeExecutionToolResultErrorCode as BetaCodeExecutionToolResultErrorCode, + type BetaCodeExecutionToolResultErrorParam as BetaCodeExecutionToolResultErrorParam, + type BetaContainer as BetaContainer, + type BetaContainerUploadBlock as BetaContainerUploadBlock, + type BetaContainerUploadBlockParam as BetaContainerUploadBlockParam, + type BetaContentBlock as BetaContentBlock, + type BetaContentBlockParam as BetaContentBlockParam, + type BetaContentBlockSource as BetaContentBlockSource, + type BetaContentBlockSourceContent as BetaContentBlockSourceContent, + type BetaFileDocumentSource as BetaFileDocumentSource, + type BetaFileImageSource as BetaFileImageSource, + type BetaImageBlockParam as BetaImageBlockParam, + type BetaInputJSONDelta as BetaInputJSONDelta, + type BetaMCPToolResultBlock as BetaMCPToolResultBlock, + type BetaMCPToolUseBlock as BetaMCPToolUseBlock, + type BetaMCPToolUseBlockParam as BetaMCPToolUseBlockParam, + type BetaMessage as BetaMessage, + type BetaMessageDeltaUsage as BetaMessageDeltaUsage, + type BetaMessageParam as BetaMessageParam, + type BetaMessageTokensCount as BetaMessageTokensCount, + type BetaMetadata as BetaMetadata, + type BetaPlainTextSource as BetaPlainTextSource, + type BetaRawContentBlockDelta as BetaRawContentBlockDelta, + type BetaRawContentBlockDeltaEvent as BetaRawContentBlockDeltaEvent, + type BetaRawContentBlockStartEvent as BetaRawContentBlockStartEvent, + type BetaRawContentBlockStopEvent as BetaRawContentBlockStopEvent, + type BetaRawMessageDeltaEvent as BetaRawMessageDeltaEvent, + type BetaRawMessageStartEvent as BetaRawMessageStartEvent, + type BetaRawMessageStopEvent as BetaRawMessageStopEvent, + type BetaRawMessageStreamEvent as BetaRawMessageStreamEvent, + type BetaRedactedThinkingBlock as BetaRedactedThinkingBlock, + type BetaRedactedThinkingBlockParam as BetaRedactedThinkingBlockParam, + type BetaRequestDocumentBlock as BetaRequestDocumentBlock, + type BetaRequestMCPServerToolConfiguration as BetaRequestMCPServerToolConfiguration, + type BetaRequestMCPServerURLDefinition as BetaRequestMCPServerURLDefinition, + type BetaRequestMCPToolResultBlockParam as BetaRequestMCPToolResultBlockParam, + type BetaSearchResultBlockParam as BetaSearchResultBlockParam, + type BetaServerToolUsage as BetaServerToolUsage, + type BetaServerToolUseBlock as BetaServerToolUseBlock, + type BetaServerToolUseBlockParam as BetaServerToolUseBlockParam, + type BetaSignatureDelta as BetaSignatureDelta, + type BetaStopReason as BetaStopReason, + type BetaTextBlock as BetaTextBlock, + type BetaTextBlockParam as BetaTextBlockParam, + type BetaTextCitation as BetaTextCitation, + type BetaTextCitationParam as BetaTextCitationParam, + type BetaTextDelta as BetaTextDelta, + type BetaThinkingBlock as BetaThinkingBlock, + type BetaThinkingBlockParam as BetaThinkingBlockParam, + type BetaThinkingConfigDisabled as BetaThinkingConfigDisabled, + type BetaThinkingConfigEnabled as BetaThinkingConfigEnabled, + type BetaThinkingConfigParam as BetaThinkingConfigParam, + type BetaThinkingDelta as BetaThinkingDelta, + type BetaTool as BetaTool, + type BetaToolBash20241022 as BetaToolBash20241022, + type BetaToolBash20250124 as BetaToolBash20250124, + type BetaToolChoice as BetaToolChoice, + type BetaToolChoiceAny as BetaToolChoiceAny, + type BetaToolChoiceAuto as BetaToolChoiceAuto, + type BetaToolChoiceNone as BetaToolChoiceNone, + type BetaToolChoiceTool as BetaToolChoiceTool, + type BetaToolComputerUse20241022 as BetaToolComputerUse20241022, + type BetaToolComputerUse20250124 as BetaToolComputerUse20250124, + type BetaToolResultBlockParam as BetaToolResultBlockParam, + type BetaToolTextEditor20241022 as BetaToolTextEditor20241022, + type BetaToolTextEditor20250124 as BetaToolTextEditor20250124, + type BetaToolTextEditor20250429 as BetaToolTextEditor20250429, + type BetaToolUnion as BetaToolUnion, + type BetaToolUseBlock as BetaToolUseBlock, + type BetaToolUseBlockParam as BetaToolUseBlockParam, + type BetaURLImageSource as BetaURLImageSource, + type BetaURLPDFSource as BetaURLPDFSource, + type BetaUsage as BetaUsage, + type BetaWebSearchResultBlock as BetaWebSearchResultBlock, + type BetaWebSearchResultBlockParam as BetaWebSearchResultBlockParam, + type BetaWebSearchTool20250305 as BetaWebSearchTool20250305, + type BetaWebSearchToolRequestError as BetaWebSearchToolRequestError, + type BetaWebSearchToolResultBlock as BetaWebSearchToolResultBlock, + type BetaWebSearchToolResultBlockContent as BetaWebSearchToolResultBlockContent, + type BetaWebSearchToolResultBlockParam as BetaWebSearchToolResultBlockParam, + type BetaWebSearchToolResultBlockParamContent as BetaWebSearchToolResultBlockParamContent, + type BetaWebSearchToolResultError as BetaWebSearchToolResultError, + type BetaWebSearchToolResultErrorCode as BetaWebSearchToolResultErrorCode, + type BetaBase64PDFBlock as BetaBase64PDFBlock, + type MessageCreateParams as MessageCreateParams, + type MessageCreateParamsNonStreaming as MessageCreateParamsNonStreaming, + type MessageCreateParamsStreaming as MessageCreateParamsStreaming, + type MessageCountTokensParams as MessageCountTokensParams, + }; + + export { + Files as Files, + type DeletedFile as DeletedFile, + type FileMetadata as FileMetadata, + type FileMetadataPage as FileMetadataPage, + type FileListParams as FileListParams, + type FileDeleteParams as FileDeleteParams, + type FileDownloadParams as FileDownloadParams, + type FileRetrieveMetadataParams as FileRetrieveMetadataParams, + type FileUploadParams as FileUploadParams, + }; +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/files.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/files.ts new file mode 100644 index 0000000000000000000000000000000000000000..448a7ee295e92c2315019b727b2d3928fe8e0a76 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/files.ts @@ -0,0 +1,258 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import { APIResource } from '../../core/resource'; +import * as BetaAPI from './beta'; +import { APIPromise } from '../../core/api-promise'; +import { Page, type PageParams, PagePromise } from '../../core/pagination'; +import { type Uploadable } from '../../core/uploads'; +import { buildHeaders } from '../../internal/headers'; +import { RequestOptions } from '../../internal/request-options'; +import { multipartFormRequestOptions } from '../../internal/uploads'; +import { path } from '../../internal/utils/path'; + +export class Files extends APIResource { + /** + * List Files + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const fileMetadata of client.beta.files.list()) { + * // ... + * } + * ``` + */ + list( + params: FileListParams | null | undefined = {}, + options?: RequestOptions, + ): PagePromise { + const { betas, ...query } = params ?? {}; + return this._client.getAPIList('/v1/files', Page, { + query, + ...options, + headers: buildHeaders([ + { 'anthropic-beta': [...(betas ?? []), 'files-api-2025-04-14'].toString() }, + options?.headers, + ]), + }); + } + + /** + * Delete File + * + * @example + * ```ts + * const deletedFile = await client.beta.files.delete( + * 'file_id', + * ); + * ``` + */ + delete( + fileID: string, + params: FileDeleteParams | null | undefined = {}, + options?: RequestOptions, + ): APIPromise { + const { betas } = params ?? {}; + return this._client.delete(path`/v1/files/${fileID}`, { + ...options, + headers: buildHeaders([ + { 'anthropic-beta': [...(betas ?? []), 'files-api-2025-04-14'].toString() }, + options?.headers, + ]), + }); + } + + /** + * Download File + * + * @example + * ```ts + * const response = await client.beta.files.download( + * 'file_id', + * ); + * + * const content = await response.blob(); + * console.log(content); + * ``` + */ + download( + fileID: string, + params: FileDownloadParams | null | undefined = {}, + options?: RequestOptions, + ): APIPromise { + const { betas } = params ?? {}; + return this._client.get(path`/v1/files/${fileID}/content`, { + ...options, + headers: buildHeaders([ + { + 'anthropic-beta': [...(betas ?? []), 'files-api-2025-04-14'].toString(), + Accept: 'application/binary', + }, + options?.headers, + ]), + __binaryResponse: true, + }); + } + + /** + * Get File Metadata + * + * @example + * ```ts + * const fileMetadata = + * await client.beta.files.retrieveMetadata('file_id'); + * ``` + */ + retrieveMetadata( + fileID: string, + params: FileRetrieveMetadataParams | null | undefined = {}, + options?: RequestOptions, + ): APIPromise { + const { betas } = params ?? {}; + return this._client.get(path`/v1/files/${fileID}`, { + ...options, + headers: buildHeaders([ + { 'anthropic-beta': [...(betas ?? []), 'files-api-2025-04-14'].toString() }, + options?.headers, + ]), + }); + } + + /** + * Upload File + * + * @example + * ```ts + * const fileMetadata = await client.beta.files.upload({ + * file: fs.createReadStream('path/to/file'), + * }); + * ``` + */ + upload(params: FileUploadParams, options?: RequestOptions): APIPromise { + const { betas, ...body } = params; + return this._client.post( + '/v1/files', + multipartFormRequestOptions( + { + body, + ...options, + headers: buildHeaders([ + { 'anthropic-beta': [...(betas ?? []), 'files-api-2025-04-14'].toString() }, + options?.headers, + ]), + }, + this._client, + ), + ); + } +} + +export type FileMetadataPage = Page; + +export interface DeletedFile { + /** + * ID of the deleted file. + */ + id: string; + + /** + * Deleted object type. + * + * For file deletion, this is always `"file_deleted"`. + */ + type?: 'file_deleted'; +} + +export interface FileMetadata { + /** + * Unique object identifier. + * + * The format and length of IDs may change over time. + */ + id: string; + + /** + * RFC 3339 datetime string representing when the file was created. + */ + created_at: string; + + /** + * Original filename of the uploaded file. + */ + filename: string; + + /** + * MIME type of the file. + */ + mime_type: string; + + /** + * Size of the file in bytes. + */ + size_bytes: number; + + /** + * Object type. + * + * For files, this is always `"file"`. + */ + type: 'file'; + + /** + * Whether the file can be downloaded. + */ + downloadable?: boolean; +} + +export interface FileListParams extends PageParams { + /** + * Header param: Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export interface FileDeleteParams { + /** + * Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export interface FileDownloadParams { + /** + * Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export interface FileRetrieveMetadataParams { + /** + * Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export interface FileUploadParams { + /** + * Body param: The file to upload + */ + file: Uploadable; + + /** + * Header param: Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export declare namespace Files { + export { + type DeletedFile as DeletedFile, + type FileMetadata as FileMetadata, + type FileMetadataPage as FileMetadataPage, + type FileListParams as FileListParams, + type FileDeleteParams as FileDeleteParams, + type FileDownloadParams as FileDownloadParams, + type FileRetrieveMetadataParams as FileRetrieveMetadataParams, + type FileUploadParams as FileUploadParams, + }; +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/index.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..1ea8a4de3fdca8560c49de6df18f503450095407 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/index.ts @@ -0,0 +1,152 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +export { + Beta, + type AnthropicBeta, + type BetaAPIError, + type BetaAuthenticationError, + type BetaBillingError, + type BetaError, + type BetaErrorResponse, + type BetaGatewayTimeoutError, + type BetaInvalidRequestError, + type BetaNotFoundError, + type BetaOverloadedError, + type BetaPermissionError, + type BetaRateLimitError, +} from './beta'; +export { + Files, + type DeletedFile, + type FileMetadata, + type FileListParams, + type FileDeleteParams, + type FileDownloadParams, + type FileRetrieveMetadataParams, + type FileUploadParams, + type FileMetadataPage, +} from './files'; +export { + Messages, + type BetaBase64ImageSource, + type BetaBase64PDFSource, + type BetaCacheControlEphemeral, + type BetaCacheCreation, + type BetaCitationCharLocation, + type BetaCitationCharLocationParam, + type BetaCitationContentBlockLocation, + type BetaCitationContentBlockLocationParam, + type BetaCitationPageLocation, + type BetaCitationPageLocationParam, + type BetaCitationSearchResultLocation, + type BetaCitationSearchResultLocationParam, + type BetaCitationWebSearchResultLocationParam, + type BetaCitationsConfigParam, + type BetaCitationsDelta, + type BetaCitationsWebSearchResultLocation, + type BetaCodeExecutionOutputBlock, + type BetaCodeExecutionOutputBlockParam, + type BetaCodeExecutionResultBlock, + type BetaCodeExecutionResultBlockParam, + type BetaCodeExecutionTool20250522, + type BetaCodeExecutionToolResultBlock, + type BetaCodeExecutionToolResultBlockContent, + type BetaCodeExecutionToolResultBlockParam, + type BetaCodeExecutionToolResultBlockParamContent, + type BetaCodeExecutionToolResultError, + type BetaCodeExecutionToolResultErrorCode, + type BetaCodeExecutionToolResultErrorParam, + type BetaContainer, + type BetaContainerUploadBlock, + type BetaContainerUploadBlockParam, + type BetaContentBlock, + type BetaContentBlockParam, + type BetaContentBlockSource, + type BetaContentBlockSourceContent, + type BetaFileDocumentSource, + type BetaFileImageSource, + type BetaImageBlockParam, + type BetaInputJSONDelta, + type BetaMCPToolResultBlock, + type BetaMCPToolUseBlock, + type BetaMCPToolUseBlockParam, + type BetaMessage, + type BetaMessageDeltaUsage, + type BetaMessageParam, + type BetaMessageTokensCount, + type BetaMetadata, + type BetaPlainTextSource, + type BetaRawContentBlockDelta, + type BetaRawContentBlockDeltaEvent, + type BetaRawContentBlockStartEvent, + type BetaRawContentBlockStopEvent, + type BetaRawMessageDeltaEvent, + type BetaRawMessageStartEvent, + type BetaRawMessageStopEvent, + type BetaRawMessageStreamEvent, + type BetaRedactedThinkingBlock, + type BetaRedactedThinkingBlockParam, + type BetaRequestDocumentBlock, + type BetaRequestMCPServerToolConfiguration, + type BetaRequestMCPServerURLDefinition, + type BetaRequestMCPToolResultBlockParam, + type BetaSearchResultBlockParam, + type BetaServerToolUsage, + type BetaServerToolUseBlock, + type BetaServerToolUseBlockParam, + type BetaSignatureDelta, + type BetaStopReason, + type BetaTextBlock, + type BetaTextBlockParam, + type BetaTextCitation, + type BetaTextCitationParam, + type BetaTextDelta, + type BetaThinkingBlock, + type BetaThinkingBlockParam, + type BetaThinkingConfigDisabled, + type BetaThinkingConfigEnabled, + type BetaThinkingConfigParam, + type BetaThinkingDelta, + type BetaTool, + type BetaToolBash20241022, + type BetaToolBash20250124, + type BetaToolChoice, + type BetaToolChoiceAny, + type BetaToolChoiceAuto, + type BetaToolChoiceNone, + type BetaToolChoiceTool, + type BetaToolComputerUse20241022, + type BetaToolComputerUse20250124, + type BetaToolResultBlockParam, + type BetaToolTextEditor20241022, + type BetaToolTextEditor20250124, + type BetaToolTextEditor20250429, + type BetaToolUnion, + type BetaToolUseBlock, + type BetaToolUseBlockParam, + type BetaURLImageSource, + type BetaURLPDFSource, + type BetaUsage, + type BetaWebSearchResultBlock, + type BetaWebSearchResultBlockParam, + type BetaWebSearchTool20250305, + type BetaWebSearchToolRequestError, + type BetaWebSearchToolResultBlock, + type BetaWebSearchToolResultBlockContent, + type BetaWebSearchToolResultBlockParam, + type BetaWebSearchToolResultBlockParamContent, + type BetaWebSearchToolResultError, + type BetaWebSearchToolResultErrorCode, + type BetaBase64PDFBlock, + type MessageCreateParams, + type MessageCreateParamsNonStreaming, + type MessageCreateParamsStreaming, + type MessageCountTokensParams, +} from './messages/index'; +export { + Models, + type BetaModelInfo, + type ModelRetrieveParams, + type ModelListParams, + type BetaModelInfosPage, +} from './models'; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/messages.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/messages.ts new file mode 100644 index 0000000000000000000000000000000000000000..eb1752308f31e493534e505ff745085107f9d210 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/messages.ts @@ -0,0 +1,3 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +export * from './messages/index'; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/messages/batches.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/messages/batches.ts new file mode 100644 index 0000000000000000000000000000000000000000..22b58628c5cc89cab58fd2a326ddd244da6935ca --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/messages/batches.ts @@ -0,0 +1,502 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import { APIResource } from '../../../core/resource'; +import * as BetaAPI from '../beta'; +import { APIPromise } from '../../../core/api-promise'; +import * as BetaMessagesAPI from './messages'; +import { Page, type PageParams, PagePromise } from '../../../core/pagination'; +import { buildHeaders } from '../../../internal/headers'; +import { RequestOptions } from '../../../internal/request-options'; +import { JSONLDecoder } from '../../../internal/decoders/jsonl'; +import { AnthropicError } from '../../../error'; +import { path } from '../../../internal/utils/path'; + +export class Batches extends APIResource { + /** + * Send a batch of Message creation requests. + * + * The Message Batches API can be used to process multiple Messages API requests at + * once. Once a Message Batch is created, it begins processing immediately. Batches + * can take up to 24 hours to complete. + * + * Learn more about the Message Batches API in our + * [user guide](/en/docs/build-with-claude/batch-processing) + * + * @example + * ```ts + * const betaMessageBatch = + * await client.beta.messages.batches.create({ + * requests: [ + * { + * custom_id: 'my-custom-id-1', + * params: { + * max_tokens: 1024, + * messages: [ + * { content: 'Hello, world', role: 'user' }, + * ], + * model: 'claude-sonnet-4-20250514', + * }, + * }, + * ], + * }); + * ``` + */ + create(params: BatchCreateParams, options?: RequestOptions): APIPromise { + const { betas, ...body } = params; + return this._client.post('/v1/messages/batches?beta=true', { + body, + ...options, + headers: buildHeaders([ + { 'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString() }, + options?.headers, + ]), + }); + } + + /** + * This endpoint is idempotent and can be used to poll for Message Batch + * completion. To access the results of a Message Batch, make a request to the + * `results_url` field in the response. + * + * Learn more about the Message Batches API in our + * [user guide](/en/docs/build-with-claude/batch-processing) + * + * @example + * ```ts + * const betaMessageBatch = + * await client.beta.messages.batches.retrieve( + * 'message_batch_id', + * ); + * ``` + */ + retrieve( + messageBatchID: string, + params: BatchRetrieveParams | null | undefined = {}, + options?: RequestOptions, + ): APIPromise { + const { betas } = params ?? {}; + return this._client.get(path`/v1/messages/batches/${messageBatchID}?beta=true`, { + ...options, + headers: buildHeaders([ + { 'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString() }, + options?.headers, + ]), + }); + } + + /** + * List all Message Batches within a Workspace. Most recently created batches are + * returned first. + * + * Learn more about the Message Batches API in our + * [user guide](/en/docs/build-with-claude/batch-processing) + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const betaMessageBatch of client.beta.messages.batches.list()) { + * // ... + * } + * ``` + */ + list( + params: BatchListParams | null | undefined = {}, + options?: RequestOptions, + ): PagePromise { + const { betas, ...query } = params ?? {}; + return this._client.getAPIList('/v1/messages/batches?beta=true', Page, { + query, + ...options, + headers: buildHeaders([ + { 'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString() }, + options?.headers, + ]), + }); + } + + /** + * Delete a Message Batch. + * + * Message Batches can only be deleted once they've finished processing. If you'd + * like to delete an in-progress batch, you must first cancel it. + * + * Learn more about the Message Batches API in our + * [user guide](/en/docs/build-with-claude/batch-processing) + * + * @example + * ```ts + * const betaDeletedMessageBatch = + * await client.beta.messages.batches.delete( + * 'message_batch_id', + * ); + * ``` + */ + delete( + messageBatchID: string, + params: BatchDeleteParams | null | undefined = {}, + options?: RequestOptions, + ): APIPromise { + const { betas } = params ?? {}; + return this._client.delete(path`/v1/messages/batches/${messageBatchID}?beta=true`, { + ...options, + headers: buildHeaders([ + { 'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString() }, + options?.headers, + ]), + }); + } + + /** + * Batches may be canceled any time before processing ends. Once cancellation is + * initiated, the batch enters a `canceling` state, at which time the system may + * complete any in-progress, non-interruptible requests before finalizing + * cancellation. + * + * The number of canceled requests is specified in `request_counts`. To determine + * which requests were canceled, check the individual results within the batch. + * Note that cancellation may not result in any canceled requests if they were + * non-interruptible. + * + * Learn more about the Message Batches API in our + * [user guide](/en/docs/build-with-claude/batch-processing) + * + * @example + * ```ts + * const betaMessageBatch = + * await client.beta.messages.batches.cancel( + * 'message_batch_id', + * ); + * ``` + */ + cancel( + messageBatchID: string, + params: BatchCancelParams | null | undefined = {}, + options?: RequestOptions, + ): APIPromise { + const { betas } = params ?? {}; + return this._client.post(path`/v1/messages/batches/${messageBatchID}/cancel?beta=true`, { + ...options, + headers: buildHeaders([ + { 'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString() }, + options?.headers, + ]), + }); + } + + /** + * Streams the results of a Message Batch as a `.jsonl` file. + * + * Each line in the file is a JSON object containing the result of a single request + * in the Message Batch. Results are not guaranteed to be in the same order as + * requests. Use the `custom_id` field to match results to requests. + * + * Learn more about the Message Batches API in our + * [user guide](/en/docs/build-with-claude/batch-processing) + * + * @example + * ```ts + * const betaMessageBatchIndividualResponse = + * await client.beta.messages.batches.results( + * 'message_batch_id', + * ); + * ``` + */ + async results( + messageBatchID: string, + params: BatchResultsParams | undefined = {}, + options?: RequestOptions, + ): Promise> { + const batch = await this.retrieve(messageBatchID); + if (!batch.results_url) { + throw new AnthropicError( + `No batch \`results_url\`; Has it finished processing? ${batch.processing_status} - ${batch.id}`, + ); + } + + const { betas } = params ?? {}; + return this._client + .get(batch.results_url, { + ...options, + headers: buildHeaders([ + { + 'anthropic-beta': [...(betas ?? []), 'message-batches-2024-09-24'].toString(), + Accept: 'application/binary', + }, + options?.headers, + ]), + stream: true, + __binaryResponse: true, + }) + ._thenUnwrap((_, props) => JSONLDecoder.fromResponse(props.response, props.controller)) as APIPromise< + JSONLDecoder + >; + } +} + +export type BetaMessageBatchesPage = Page; + +export interface BetaDeletedMessageBatch { + /** + * ID of the Message Batch. + */ + id: string; + + /** + * Deleted object type. + * + * For Message Batches, this is always `"message_batch_deleted"`. + */ + type: 'message_batch_deleted'; +} + +export interface BetaMessageBatch { + /** + * Unique object identifier. + * + * The format and length of IDs may change over time. + */ + id: string; + + /** + * RFC 3339 datetime string representing the time at which the Message Batch was + * archived and its results became unavailable. + */ + archived_at: string | null; + + /** + * RFC 3339 datetime string representing the time at which cancellation was + * initiated for the Message Batch. Specified only if cancellation was initiated. + */ + cancel_initiated_at: string | null; + + /** + * RFC 3339 datetime string representing the time at which the Message Batch was + * created. + */ + created_at: string; + + /** + * RFC 3339 datetime string representing the time at which processing for the + * Message Batch ended. Specified only once processing ends. + * + * Processing ends when every request in a Message Batch has either succeeded, + * errored, canceled, or expired. + */ + ended_at: string | null; + + /** + * RFC 3339 datetime string representing the time at which the Message Batch will + * expire and end processing, which is 24 hours after creation. + */ + expires_at: string; + + /** + * Processing status of the Message Batch. + */ + processing_status: 'in_progress' | 'canceling' | 'ended'; + + /** + * Tallies requests within the Message Batch, categorized by their status. + * + * Requests start as `processing` and move to one of the other statuses only once + * processing of the entire batch ends. The sum of all values always matches the + * total number of requests in the batch. + */ + request_counts: BetaMessageBatchRequestCounts; + + /** + * URL to a `.jsonl` file containing the results of the Message Batch requests. + * Specified only once processing ends. + * + * Results in the file are not guaranteed to be in the same order as requests. Use + * the `custom_id` field to match results to requests. + */ + results_url: string | null; + + /** + * Object type. + * + * For Message Batches, this is always `"message_batch"`. + */ + type: 'message_batch'; +} + +export interface BetaMessageBatchCanceledResult { + type: 'canceled'; +} + +export interface BetaMessageBatchErroredResult { + error: BetaAPI.BetaErrorResponse; + + type: 'errored'; +} + +export interface BetaMessageBatchExpiredResult { + type: 'expired'; +} + +/** + * This is a single line in the response `.jsonl` file and does not represent the + * response as a whole. + */ +export interface BetaMessageBatchIndividualResponse { + /** + * Developer-provided ID created for each request in a Message Batch. Useful for + * matching results to requests, as results may be given out of request order. + * + * Must be unique for each request within the Message Batch. + */ + custom_id: string; + + /** + * Processing result for this request. + * + * Contains a Message output if processing was successful, an error response if + * processing failed, or the reason why processing was not attempted, such as + * cancellation or expiration. + */ + result: BetaMessageBatchResult; +} + +export interface BetaMessageBatchRequestCounts { + /** + * Number of requests in the Message Batch that have been canceled. + * + * This is zero until processing of the entire Message Batch has ended. + */ + canceled: number; + + /** + * Number of requests in the Message Batch that encountered an error. + * + * This is zero until processing of the entire Message Batch has ended. + */ + errored: number; + + /** + * Number of requests in the Message Batch that have expired. + * + * This is zero until processing of the entire Message Batch has ended. + */ + expired: number; + + /** + * Number of requests in the Message Batch that are processing. + */ + processing: number; + + /** + * Number of requests in the Message Batch that have completed successfully. + * + * This is zero until processing of the entire Message Batch has ended. + */ + succeeded: number; +} + +/** + * Processing result for this request. + * + * Contains a Message output if processing was successful, an error response if + * processing failed, or the reason why processing was not attempted, such as + * cancellation or expiration. + */ +export type BetaMessageBatchResult = + | BetaMessageBatchSucceededResult + | BetaMessageBatchErroredResult + | BetaMessageBatchCanceledResult + | BetaMessageBatchExpiredResult; + +export interface BetaMessageBatchSucceededResult { + message: BetaMessagesAPI.BetaMessage; + + type: 'succeeded'; +} + +export interface BatchCreateParams { + /** + * Body param: List of requests for prompt completion. Each is an individual + * request to create a Message. + */ + requests: Array; + + /** + * Header param: Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export namespace BatchCreateParams { + export interface Request { + /** + * Developer-provided ID created for each request in a Message Batch. Useful for + * matching results to requests, as results may be given out of request order. + * + * Must be unique for each request within the Message Batch. + */ + custom_id: string; + + /** + * Messages API creation parameters for the individual request. + * + * See the [Messages API reference](/en/api/messages) for full documentation on + * available parameters. + */ + params: Omit; + } +} + +export interface BatchRetrieveParams { + /** + * Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export interface BatchListParams extends PageParams { + /** + * Header param: Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export interface BatchDeleteParams { + /** + * Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export interface BatchCancelParams { + /** + * Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export interface BatchResultsParams { + /** + * Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export declare namespace Batches { + export { + type BetaDeletedMessageBatch as BetaDeletedMessageBatch, + type BetaMessageBatch as BetaMessageBatch, + type BetaMessageBatchCanceledResult as BetaMessageBatchCanceledResult, + type BetaMessageBatchErroredResult as BetaMessageBatchErroredResult, + type BetaMessageBatchExpiredResult as BetaMessageBatchExpiredResult, + type BetaMessageBatchIndividualResponse as BetaMessageBatchIndividualResponse, + type BetaMessageBatchRequestCounts as BetaMessageBatchRequestCounts, + type BetaMessageBatchResult as BetaMessageBatchResult, + type BetaMessageBatchSucceededResult as BetaMessageBatchSucceededResult, + type BetaMessageBatchesPage as BetaMessageBatchesPage, + type BatchCreateParams as BatchCreateParams, + type BatchRetrieveParams as BatchRetrieveParams, + type BatchListParams as BatchListParams, + type BatchDeleteParams as BatchDeleteParams, + type BatchCancelParams as BatchCancelParams, + type BatchResultsParams as BatchResultsParams, + }; +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/messages/index.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/messages/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..4987f024e2a76b917a87a4729f0432bae4963783 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/messages/index.ts @@ -0,0 +1,139 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +export { + Batches, + type BetaDeletedMessageBatch, + type BetaMessageBatch, + type BetaMessageBatchCanceledResult, + type BetaMessageBatchErroredResult, + type BetaMessageBatchExpiredResult, + type BetaMessageBatchIndividualResponse, + type BetaMessageBatchRequestCounts, + type BetaMessageBatchResult, + type BetaMessageBatchSucceededResult, + type BatchCreateParams, + type BatchRetrieveParams, + type BatchListParams, + type BatchDeleteParams, + type BatchCancelParams, + type BatchResultsParams, + type BetaMessageBatchesPage, +} from './batches'; +export { + Messages, + type BetaBase64ImageSource, + type BetaBase64PDFSource, + type BetaCacheControlEphemeral, + type BetaCacheCreation, + type BetaCitationCharLocation, + type BetaCitationCharLocationParam, + type BetaCitationContentBlockLocation, + type BetaCitationContentBlockLocationParam, + type BetaCitationPageLocation, + type BetaCitationPageLocationParam, + type BetaCitationSearchResultLocation, + type BetaCitationSearchResultLocationParam, + type BetaCitationWebSearchResultLocationParam, + type BetaCitationsConfigParam, + type BetaCitationsDelta, + type BetaCitationsWebSearchResultLocation, + type BetaCodeExecutionOutputBlock, + type BetaCodeExecutionOutputBlockParam, + type BetaCodeExecutionResultBlock, + type BetaCodeExecutionResultBlockParam, + type BetaCodeExecutionTool20250522, + type BetaCodeExecutionToolResultBlock, + type BetaCodeExecutionToolResultBlockContent, + type BetaCodeExecutionToolResultBlockParam, + type BetaCodeExecutionToolResultBlockParamContent, + type BetaCodeExecutionToolResultError, + type BetaCodeExecutionToolResultErrorCode, + type BetaCodeExecutionToolResultErrorParam, + type BetaContainer, + type BetaContainerUploadBlock, + type BetaContainerUploadBlockParam, + type BetaContentBlock, + type BetaContentBlockParam, + type BetaContentBlockSource, + type BetaContentBlockSourceContent, + type BetaFileDocumentSource, + type BetaFileImageSource, + type BetaImageBlockParam, + type BetaInputJSONDelta, + type BetaMCPToolResultBlock, + type BetaMCPToolUseBlock, + type BetaMCPToolUseBlockParam, + type BetaMessage, + type BetaMessageDeltaUsage, + type BetaMessageParam, + type BetaMessageTokensCount, + type BetaMetadata, + type BetaPlainTextSource, + type BetaRawContentBlockDelta, + type BetaRawContentBlockDeltaEvent, + type BetaRawContentBlockStartEvent, + type BetaRawContentBlockStopEvent, + type BetaRawMessageDeltaEvent, + type BetaRawMessageStartEvent, + type BetaRawMessageStopEvent, + type BetaRawMessageStreamEvent, + type BetaRedactedThinkingBlock, + type BetaRedactedThinkingBlockParam, + type BetaRequestDocumentBlock, + type BetaRequestMCPServerToolConfiguration, + type BetaRequestMCPServerURLDefinition, + type BetaRequestMCPToolResultBlockParam, + type BetaSearchResultBlockParam, + type BetaServerToolUsage, + type BetaServerToolUseBlock, + type BetaServerToolUseBlockParam, + type BetaSignatureDelta, + type BetaStopReason, + type BetaTextBlock, + type BetaTextBlockParam, + type BetaTextCitation, + type BetaTextCitationParam, + type BetaTextDelta, + type BetaThinkingBlock, + type BetaThinkingBlockParam, + type BetaThinkingConfigDisabled, + type BetaThinkingConfigEnabled, + type BetaThinkingConfigParam, + type BetaThinkingDelta, + type BetaTool, + type BetaToolBash20241022, + type BetaToolBash20250124, + type BetaToolChoice, + type BetaToolChoiceAny, + type BetaToolChoiceAuto, + type BetaToolChoiceNone, + type BetaToolChoiceTool, + type BetaToolComputerUse20241022, + type BetaToolComputerUse20250124, + type BetaToolResultBlockParam, + type BetaToolTextEditor20241022, + type BetaToolTextEditor20250124, + type BetaToolTextEditor20250429, + type BetaToolUnion, + type BetaToolUseBlock, + type BetaToolUseBlockParam, + type BetaURLImageSource, + type BetaURLPDFSource, + type BetaUsage, + type BetaWebSearchResultBlock, + type BetaWebSearchResultBlockParam, + type BetaWebSearchTool20250305, + type BetaWebSearchToolRequestError, + type BetaWebSearchToolResultBlock, + type BetaWebSearchToolResultBlockContent, + type BetaWebSearchToolResultBlockParam, + type BetaWebSearchToolResultBlockParamContent, + type BetaWebSearchToolResultError, + type BetaWebSearchToolResultErrorCode, + type BetaBase64PDFBlock, + type MessageCreateParams, + type MessageCreateParamsNonStreaming, + type MessageCreateParamsStreaming, + type MessageCountTokensParams, + type BetaMessageStreamParams, +} from './messages'; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/messages/messages.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/messages/messages.ts new file mode 100644 index 0000000000000000000000000000000000000000..c59c154a309245a96b36b11d173fd912b3afee51 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/messages/messages.ts @@ -0,0 +1,2330 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import { APIResource } from '../../../core/resource'; +import * as MessagesMessagesAPI from './messages'; +import * as BetaAPI from '../beta'; +import * as MessagesAPI from '../../messages/messages'; +import * as BatchesAPI from './batches'; +import { + BatchCancelParams, + BatchCreateParams, + BatchDeleteParams, + BatchListParams, + BatchResultsParams, + BatchRetrieveParams, + Batches, + BetaDeletedMessageBatch, + BetaMessageBatch, + BetaMessageBatchCanceledResult, + BetaMessageBatchErroredResult, + BetaMessageBatchExpiredResult, + BetaMessageBatchIndividualResponse, + BetaMessageBatchRequestCounts, + BetaMessageBatchResult, + BetaMessageBatchSucceededResult, + BetaMessageBatchesPage, +} from './batches'; +import { APIPromise } from '../../../core/api-promise'; +import { Stream } from '../../../core/streaming'; +import { buildHeaders } from '../../../internal/headers'; +import { RequestOptions } from '../../../internal/request-options'; +import type { Model } from '../../messages/messages'; +import { BetaMessageStream } from '../../../lib/BetaMessageStream'; + +const DEPRECATED_MODELS: { + [K in Model]?: string; +} = { + 'claude-1.3': 'November 6th, 2024', + 'claude-1.3-100k': 'November 6th, 2024', + 'claude-instant-1.1': 'November 6th, 2024', + 'claude-instant-1.1-100k': 'November 6th, 2024', + 'claude-instant-1.2': 'November 6th, 2024', + 'claude-3-sonnet-20240229': 'July 21st, 2025', + 'claude-3-opus-20240229': 'January 5th, 2026', + 'claude-2.1': 'July 21st, 2025', + 'claude-2.0': 'July 21st, 2025', +}; +import { MODEL_NONSTREAMING_TOKENS } from '../../../internal/constants'; + +export class Messages extends APIResource { + batches: BatchesAPI.Batches = new BatchesAPI.Batches(this._client); + + /** + * Send a structured list of input messages with text and/or image content, and the + * model will generate the next message in the conversation. + * + * The Messages API can be used for either single queries or stateless multi-turn + * conversations. + * + * Learn more about the Messages API in our [user guide](/en/docs/initial-setup) + * + * @example + * ```ts + * const betaMessage = await client.beta.messages.create({ + * max_tokens: 1024, + * messages: [{ content: 'Hello, world', role: 'user' }], + * model: 'claude-sonnet-4-20250514', + * }); + * ``` + */ + create(params: MessageCreateParamsNonStreaming, options?: RequestOptions): APIPromise; + create( + params: MessageCreateParamsStreaming, + options?: RequestOptions, + ): APIPromise>; + create( + params: MessageCreateParamsBase, + options?: RequestOptions, + ): APIPromise | BetaMessage>; + create( + params: MessageCreateParams, + options?: RequestOptions, + ): APIPromise | APIPromise> { + const { betas, ...body } = params; + + if (body.model in DEPRECATED_MODELS) { + console.warn( + `The model '${body.model}' is deprecated and will reach end-of-life on ${ + DEPRECATED_MODELS[body.model] + }\nPlease migrate to a newer model. Visit https://docs.anthropic.com/en/docs/resources/model-deprecations for more information.`, + ); + } + + let timeout = (this._client as any)._options.timeout as number | null; + if (!body.stream && timeout == null) { + const maxNonstreamingTokens = MODEL_NONSTREAMING_TOKENS[body.model] ?? undefined; + timeout = this._client.calculateNonstreamingTimeout(body.max_tokens, maxNonstreamingTokens); + } + return this._client.post('/v1/messages?beta=true', { + body, + timeout: timeout ?? 600000, + ...options, + headers: buildHeaders([ + { ...(betas?.toString() != null ? { 'anthropic-beta': betas?.toString() } : undefined) }, + options?.headers, + ]), + stream: params.stream ?? false, + }) as APIPromise | APIPromise>; + } + + /** + * Create a Message stream + */ + stream(body: BetaMessageStreamParams, options?: RequestOptions): BetaMessageStream { + return BetaMessageStream.createMessage(this, body, options); + } + + /** + * Count the number of tokens in a Message. + * + * The Token Count API can be used to count the number of tokens in a Message, + * including tools, images, and documents, without creating it. + * + * Learn more about token counting in our + * [user guide](/en/docs/build-with-claude/token-counting) + * + * @example + * ```ts + * const betaMessageTokensCount = + * await client.beta.messages.countTokens({ + * messages: [{ content: 'string', role: 'user' }], + * model: 'claude-3-7-sonnet-latest', + * }); + * ``` + */ + countTokens( + params: MessageCountTokensParams, + options?: RequestOptions, + ): APIPromise { + const { betas, ...body } = params; + return this._client.post('/v1/messages/count_tokens?beta=true', { + body, + ...options, + headers: buildHeaders([ + { 'anthropic-beta': [...(betas ?? []), 'token-counting-2024-11-01'].toString() }, + options?.headers, + ]), + }); + } +} + +export type BetaMessageStreamParams = MessageCreateParamsBase; + +export interface BetaBase64ImageSource { + data: string; + + media_type: 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp'; + + type: 'base64'; +} + +export interface BetaBase64PDFSource { + data: string; + + media_type: 'application/pdf'; + + type: 'base64'; +} + +export interface BetaCacheControlEphemeral { + type: 'ephemeral'; + + /** + * The time-to-live for the cache control breakpoint. + * + * This may be one the following values: + * + * - `5m`: 5 minutes + * - `1h`: 1 hour + * + * Defaults to `5m`. + */ + ttl?: '5m' | '1h'; +} + +export interface BetaCacheCreation { + /** + * The number of input tokens used to create the 1 hour cache entry. + */ + ephemeral_1h_input_tokens: number; + + /** + * The number of input tokens used to create the 5 minute cache entry. + */ + ephemeral_5m_input_tokens: number; +} + +export interface BetaCitationCharLocation { + cited_text: string; + + document_index: number; + + document_title: string | null; + + end_char_index: number; + + start_char_index: number; + + type: 'char_location'; +} + +export interface BetaCitationCharLocationParam { + cited_text: string; + + document_index: number; + + document_title: string | null; + + end_char_index: number; + + start_char_index: number; + + type: 'char_location'; +} + +export interface BetaCitationContentBlockLocation { + cited_text: string; + + document_index: number; + + document_title: string | null; + + end_block_index: number; + + start_block_index: number; + + type: 'content_block_location'; +} + +export interface BetaCitationContentBlockLocationParam { + cited_text: string; + + document_index: number; + + document_title: string | null; + + end_block_index: number; + + start_block_index: number; + + type: 'content_block_location'; +} + +export interface BetaCitationPageLocation { + cited_text: string; + + document_index: number; + + document_title: string | null; + + end_page_number: number; + + start_page_number: number; + + type: 'page_location'; +} + +export interface BetaCitationPageLocationParam { + cited_text: string; + + document_index: number; + + document_title: string | null; + + end_page_number: number; + + start_page_number: number; + + type: 'page_location'; +} + +export interface BetaCitationSearchResultLocation { + cited_text: string; + + end_block_index: number; + + search_result_index: number; + + source: string; + + start_block_index: number; + + title: string | null; + + type: 'search_result_location'; +} + +export interface BetaCitationSearchResultLocationParam { + cited_text: string; + + end_block_index: number; + + search_result_index: number; + + source: string; + + start_block_index: number; + + title: string | null; + + type: 'search_result_location'; +} + +export interface BetaCitationWebSearchResultLocationParam { + cited_text: string; + + encrypted_index: string; + + title: string | null; + + type: 'web_search_result_location'; + + url: string; +} + +export interface BetaCitationsConfigParam { + enabled?: boolean; +} + +export interface BetaCitationsDelta { + citation: + | BetaCitationCharLocation + | BetaCitationPageLocation + | BetaCitationContentBlockLocation + | BetaCitationsWebSearchResultLocation + | BetaCitationSearchResultLocation; + + type: 'citations_delta'; +} + +export interface BetaCitationsWebSearchResultLocation { + cited_text: string; + + encrypted_index: string; + + title: string | null; + + type: 'web_search_result_location'; + + url: string; +} + +export interface BetaCodeExecutionOutputBlock { + file_id: string; + + type: 'code_execution_output'; +} + +export interface BetaCodeExecutionOutputBlockParam { + file_id: string; + + type: 'code_execution_output'; +} + +export interface BetaCodeExecutionResultBlock { + content: Array; + + return_code: number; + + stderr: string; + + stdout: string; + + type: 'code_execution_result'; +} + +export interface BetaCodeExecutionResultBlockParam { + content: Array; + + return_code: number; + + stderr: string; + + stdout: string; + + type: 'code_execution_result'; +} + +export interface BetaCodeExecutionTool20250522 { + /** + * Name of the tool. + * + * This is how the tool will be called by the model and in `tool_use` blocks. + */ + name: 'code_execution'; + + type: 'code_execution_20250522'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; +} + +export interface BetaCodeExecutionToolResultBlock { + content: BetaCodeExecutionToolResultBlockContent; + + tool_use_id: string; + + type: 'code_execution_tool_result'; +} + +export type BetaCodeExecutionToolResultBlockContent = + | BetaCodeExecutionToolResultError + | BetaCodeExecutionResultBlock; + +export interface BetaCodeExecutionToolResultBlockParam { + content: BetaCodeExecutionToolResultBlockParamContent; + + tool_use_id: string; + + type: 'code_execution_tool_result'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; +} + +export type BetaCodeExecutionToolResultBlockParamContent = + | BetaCodeExecutionToolResultErrorParam + | BetaCodeExecutionResultBlockParam; + +export interface BetaCodeExecutionToolResultError { + error_code: BetaCodeExecutionToolResultErrorCode; + + type: 'code_execution_tool_result_error'; +} + +export type BetaCodeExecutionToolResultErrorCode = + | 'invalid_tool_input' + | 'unavailable' + | 'too_many_requests' + | 'execution_time_exceeded'; + +export interface BetaCodeExecutionToolResultErrorParam { + error_code: BetaCodeExecutionToolResultErrorCode; + + type: 'code_execution_tool_result_error'; +} + +/** + * Information about the container used in the request (for the code execution + * tool) + */ +export interface BetaContainer { + /** + * Identifier for the container used in this request + */ + id: string; + + /** + * The time at which the container will expire. + */ + expires_at: string; +} + +/** + * Response model for a file uploaded to the container. + */ +export interface BetaContainerUploadBlock { + file_id: string; + + type: 'container_upload'; +} + +/** + * A content block that represents a file to be uploaded to the container Files + * uploaded via this block will be available in the container's input directory. + */ +export interface BetaContainerUploadBlockParam { + file_id: string; + + type: 'container_upload'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; +} + +/** + * Response model for a file uploaded to the container. + */ +export type BetaContentBlock = + | BetaTextBlock + | BetaThinkingBlock + | BetaRedactedThinkingBlock + | BetaToolUseBlock + | BetaServerToolUseBlock + | BetaWebSearchToolResultBlock + | BetaCodeExecutionToolResultBlock + | BetaMCPToolUseBlock + | BetaMCPToolResultBlock + | BetaContainerUploadBlock; + +/** + * Regular text content. + */ +export type BetaContentBlockParam = + | BetaTextBlockParam + | BetaImageBlockParam + | BetaRequestDocumentBlock + | BetaSearchResultBlockParam + | BetaThinkingBlockParam + | BetaRedactedThinkingBlockParam + | BetaToolUseBlockParam + | BetaToolResultBlockParam + | BetaServerToolUseBlockParam + | BetaWebSearchToolResultBlockParam + | BetaCodeExecutionToolResultBlockParam + | BetaMCPToolUseBlockParam + | BetaRequestMCPToolResultBlockParam + | BetaContainerUploadBlockParam; + +export interface BetaContentBlockSource { + content: string | Array; + + type: 'content'; +} + +export type BetaContentBlockSourceContent = BetaTextBlockParam | BetaImageBlockParam; + +export interface BetaFileDocumentSource { + file_id: string; + + type: 'file'; +} + +export interface BetaFileImageSource { + file_id: string; + + type: 'file'; +} + +export interface BetaImageBlockParam { + source: BetaBase64ImageSource | BetaURLImageSource | BetaFileImageSource; + + type: 'image'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; +} + +export interface BetaInputJSONDelta { + partial_json: string; + + type: 'input_json_delta'; +} + +export interface BetaMCPToolResultBlock { + content: string | Array; + + is_error: boolean; + + tool_use_id: string; + + type: 'mcp_tool_result'; +} + +export interface BetaMCPToolUseBlock { + id: string; + + input: unknown; + + /** + * The name of the MCP tool + */ + name: string; + + /** + * The name of the MCP server + */ + server_name: string; + + type: 'mcp_tool_use'; +} + +export interface BetaMCPToolUseBlockParam { + id: string; + + input: unknown; + + name: string; + + /** + * The name of the MCP server + */ + server_name: string; + + type: 'mcp_tool_use'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; +} + +export interface BetaMessage { + /** + * Unique object identifier. + * + * The format and length of IDs may change over time. + */ + id: string; + + /** + * Information about the container used in the request (for the code execution + * tool) + */ + container: BetaContainer | null; + + /** + * Content generated by the model. + * + * This is an array of content blocks, each of which has a `type` that determines + * its shape. + * + * Example: + * + * ```json + * [{ "type": "text", "text": "Hi, I'm Claude." }] + * ``` + * + * If the request input `messages` ended with an `assistant` turn, then the + * response `content` will continue directly from that last turn. You can use this + * to constrain the model's output. + * + * For example, if the input `messages` were: + * + * ```json + * [ + * { + * "role": "user", + * "content": "What's the Greek name for Sun? (A) Sol (B) Helios (C) Sun" + * }, + * { "role": "assistant", "content": "The best answer is (" } + * ] + * ``` + * + * Then the response `content` might be: + * + * ```json + * [{ "type": "text", "text": "B)" }] + * ``` + */ + content: Array; + + /** + * The model that will complete your prompt.\n\nSee + * [models](https://docs.anthropic.com/en/docs/models-overview) for additional + * details and options. + */ + model: MessagesAPI.Model; + + /** + * Conversational role of the generated message. + * + * This will always be `"assistant"`. + */ + role: 'assistant'; + + /** + * The reason that we stopped. + * + * This may be one the following values: + * + * - `"end_turn"`: the model reached a natural stopping point + * - `"max_tokens"`: we exceeded the requested `max_tokens` or the model's maximum + * - `"stop_sequence"`: one of your provided custom `stop_sequences` was generated + * - `"tool_use"`: the model invoked one or more tools + * - `"pause_turn"`: we paused a long-running turn. You may provide the response + * back as-is in a subsequent request to let the model continue. + * - `"refusal"`: when streaming classifiers intervene to handle potential policy + * violations + * + * In non-streaming mode this value is always non-null. In streaming mode, it is + * null in the `message_start` event and non-null otherwise. + */ + stop_reason: BetaStopReason | null; + + /** + * Which custom stop sequence was generated, if any. + * + * This value will be a non-null string if one of your custom stop sequences was + * generated. + */ + stop_sequence: string | null; + + /** + * Object type. + * + * For Messages, this is always `"message"`. + */ + type: 'message'; + + /** + * Billing and rate-limit usage. + * + * Anthropic's API bills and rate-limits by token counts, as tokens represent the + * underlying cost to our systems. + * + * Under the hood, the API transforms requests into a format suitable for the + * model. The model's output then goes through a parsing stage before becoming an + * API response. As a result, the token counts in `usage` will not match one-to-one + * with the exact visible content of an API request or response. + * + * For example, `output_tokens` will be non-zero, even for an empty string response + * from Claude. + * + * Total input tokens in a request is the summation of `input_tokens`, + * `cache_creation_input_tokens`, and `cache_read_input_tokens`. + */ + usage: BetaUsage; +} + +export interface BetaMessageDeltaUsage { + /** + * The cumulative number of input tokens used to create the cache entry. + */ + cache_creation_input_tokens: number | null; + + /** + * The cumulative number of input tokens read from the cache. + */ + cache_read_input_tokens: number | null; + + /** + * The cumulative number of input tokens which were used. + */ + input_tokens: number | null; + + /** + * The cumulative number of output tokens which were used. + */ + output_tokens: number; + + /** + * The number of server tool requests. + */ + server_tool_use: BetaServerToolUsage | null; +} + +export interface BetaMessageParam { + content: string | Array; + + role: 'user' | 'assistant'; +} + +export interface BetaMessageTokensCount { + /** + * The total number of tokens across the provided list of messages, system prompt, + * and tools. + */ + input_tokens: number; +} + +export interface BetaMetadata { + /** + * An external identifier for the user who is associated with the request. + * + * This should be a uuid, hash value, or other opaque identifier. Anthropic may use + * this id to help detect abuse. Do not include any identifying information such as + * name, email address, or phone number. + */ + user_id?: string | null; +} + +export interface BetaPlainTextSource { + data: string; + + media_type: 'text/plain'; + + type: 'text'; +} + +export type BetaRawContentBlockDelta = + | BetaTextDelta + | BetaInputJSONDelta + | BetaCitationsDelta + | BetaThinkingDelta + | BetaSignatureDelta; + +export interface BetaRawContentBlockDeltaEvent { + delta: BetaRawContentBlockDelta; + + index: number; + + type: 'content_block_delta'; +} + +export interface BetaRawContentBlockStartEvent { + /** + * Response model for a file uploaded to the container. + */ + content_block: + | BetaTextBlock + | BetaThinkingBlock + | BetaRedactedThinkingBlock + | BetaToolUseBlock + | BetaServerToolUseBlock + | BetaWebSearchToolResultBlock + | BetaCodeExecutionToolResultBlock + | BetaMCPToolUseBlock + | BetaMCPToolResultBlock + | BetaContainerUploadBlock; + + index: number; + + type: 'content_block_start'; +} + +export interface BetaRawContentBlockStopEvent { + index: number; + + type: 'content_block_stop'; +} + +export interface BetaRawMessageDeltaEvent { + delta: BetaRawMessageDeltaEvent.Delta; + + type: 'message_delta'; + + /** + * Billing and rate-limit usage. + * + * Anthropic's API bills and rate-limits by token counts, as tokens represent the + * underlying cost to our systems. + * + * Under the hood, the API transforms requests into a format suitable for the + * model. The model's output then goes through a parsing stage before becoming an + * API response. As a result, the token counts in `usage` will not match one-to-one + * with the exact visible content of an API request or response. + * + * For example, `output_tokens` will be non-zero, even for an empty string response + * from Claude. + * + * Total input tokens in a request is the summation of `input_tokens`, + * `cache_creation_input_tokens`, and `cache_read_input_tokens`. + */ + usage: BetaMessageDeltaUsage; +} + +export namespace BetaRawMessageDeltaEvent { + export interface Delta { + /** + * Information about the container used in the request (for the code execution + * tool) + */ + container: MessagesMessagesAPI.BetaContainer | null; + + stop_reason: MessagesMessagesAPI.BetaStopReason | null; + + stop_sequence: string | null; + } +} + +export interface BetaRawMessageStartEvent { + message: BetaMessage; + + type: 'message_start'; +} + +export interface BetaRawMessageStopEvent { + type: 'message_stop'; +} + +export type BetaRawMessageStreamEvent = + | BetaRawMessageStartEvent + | BetaRawMessageDeltaEvent + | BetaRawMessageStopEvent + | BetaRawContentBlockStartEvent + | BetaRawContentBlockDeltaEvent + | BetaRawContentBlockStopEvent; + +export interface BetaRedactedThinkingBlock { + data: string; + + type: 'redacted_thinking'; +} + +export interface BetaRedactedThinkingBlockParam { + data: string; + + type: 'redacted_thinking'; +} + +export interface BetaRequestDocumentBlock { + source: + | BetaBase64PDFSource + | BetaPlainTextSource + | BetaContentBlockSource + | BetaURLPDFSource + | BetaFileDocumentSource; + + type: 'document'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; + + citations?: BetaCitationsConfigParam; + + context?: string | null; + + title?: string | null; +} + +export interface BetaRequestMCPServerToolConfiguration { + allowed_tools?: Array | null; + + enabled?: boolean | null; +} + +export interface BetaRequestMCPServerURLDefinition { + name: string; + + type: 'url'; + + url: string; + + authorization_token?: string | null; + + tool_configuration?: BetaRequestMCPServerToolConfiguration | null; +} + +export interface BetaRequestMCPToolResultBlockParam { + tool_use_id: string; + + type: 'mcp_tool_result'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; + + content?: string | Array; + + is_error?: boolean; +} + +export interface BetaSearchResultBlockParam { + content: Array; + + source: string; + + title: string; + + type: 'search_result'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; + + citations?: BetaCitationsConfigParam; +} + +export interface BetaServerToolUsage { + /** + * The number of web search tool requests. + */ + web_search_requests: number; +} + +export interface BetaServerToolUseBlock { + id: string; + + input: unknown; + + name: 'web_search' | 'code_execution'; + + type: 'server_tool_use'; +} + +export interface BetaServerToolUseBlockParam { + id: string; + + input: unknown; + + name: 'web_search' | 'code_execution'; + + type: 'server_tool_use'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; +} + +export interface BetaSignatureDelta { + signature: string; + + type: 'signature_delta'; +} + +export type BetaStopReason = + | 'end_turn' + | 'max_tokens' + | 'stop_sequence' + | 'tool_use' + | 'pause_turn' + | 'refusal'; + +export interface BetaTextBlock { + /** + * Citations supporting the text block. + * + * The type of citation returned will depend on the type of document being cited. + * Citing a PDF results in `page_location`, plain text results in `char_location`, + * and content document results in `content_block_location`. + */ + citations: Array | null; + + text: string; + + type: 'text'; +} + +export interface BetaTextBlockParam { + text: string; + + type: 'text'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; + + citations?: Array | null; +} + +export type BetaTextCitation = + | BetaCitationCharLocation + | BetaCitationPageLocation + | BetaCitationContentBlockLocation + | BetaCitationsWebSearchResultLocation + | BetaCitationSearchResultLocation; + +export type BetaTextCitationParam = + | BetaCitationCharLocationParam + | BetaCitationPageLocationParam + | BetaCitationContentBlockLocationParam + | BetaCitationWebSearchResultLocationParam + | BetaCitationSearchResultLocationParam; + +export interface BetaTextDelta { + text: string; + + type: 'text_delta'; +} + +export interface BetaThinkingBlock { + signature: string; + + thinking: string; + + type: 'thinking'; +} + +export interface BetaThinkingBlockParam { + signature: string; + + thinking: string; + + type: 'thinking'; +} + +export interface BetaThinkingConfigDisabled { + type: 'disabled'; +} + +export interface BetaThinkingConfigEnabled { + /** + * Determines how many tokens Claude can use for its internal reasoning process. + * Larger budgets can enable more thorough analysis for complex problems, improving + * response quality. + * + * Must be ≥1024 and less than `max_tokens`. + * + * See + * [extended thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking) + * for details. + */ + budget_tokens: number; + + type: 'enabled'; +} + +/** + * Configuration for enabling Claude's extended thinking. + * + * When enabled, responses include `thinking` content blocks showing Claude's + * thinking process before the final answer. Requires a minimum budget of 1,024 + * tokens and counts towards your `max_tokens` limit. + * + * See + * [extended thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking) + * for details. + */ +export type BetaThinkingConfigParam = BetaThinkingConfigEnabled | BetaThinkingConfigDisabled; + +export interface BetaThinkingDelta { + thinking: string; + + type: 'thinking_delta'; +} + +export interface BetaTool { + /** + * [JSON schema](https://json-schema.org/draft/2020-12) for this tool's input. + * + * This defines the shape of the `input` that your tool accepts and that the model + * will produce. + */ + input_schema: BetaTool.InputSchema; + + /** + * Name of the tool. + * + * This is how the tool will be called by the model and in `tool_use` blocks. + */ + name: string; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; + + /** + * Description of what this tool does. + * + * Tool descriptions should be as detailed as possible. The more information that + * the model has about what the tool is and how to use it, the better it will + * perform. You can use natural language descriptions to reinforce important + * aspects of the tool input JSON schema. + */ + description?: string; + + type?: 'custom' | null; +} + +export namespace BetaTool { + /** + * [JSON schema](https://json-schema.org/draft/2020-12) for this tool's input. + * + * This defines the shape of the `input` that your tool accepts and that the model + * will produce. + */ + export interface InputSchema { + type: 'object'; + + properties?: unknown | null; + + required?: Array | null; + + [k: string]: unknown; + } +} + +export interface BetaToolBash20241022 { + /** + * Name of the tool. + * + * This is how the tool will be called by the model and in `tool_use` blocks. + */ + name: 'bash'; + + type: 'bash_20241022'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; +} + +export interface BetaToolBash20250124 { + /** + * Name of the tool. + * + * This is how the tool will be called by the model and in `tool_use` blocks. + */ + name: 'bash'; + + type: 'bash_20250124'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; +} + +/** + * How the model should use the provided tools. The model can use a specific tool, + * any available tool, decide by itself, or not use tools at all. + */ +export type BetaToolChoice = BetaToolChoiceAuto | BetaToolChoiceAny | BetaToolChoiceTool | BetaToolChoiceNone; + +/** + * The model will use any available tools. + */ +export interface BetaToolChoiceAny { + type: 'any'; + + /** + * Whether to disable parallel tool use. + * + * Defaults to `false`. If set to `true`, the model will output exactly one tool + * use. + */ + disable_parallel_tool_use?: boolean; +} + +/** + * The model will automatically decide whether to use tools. + */ +export interface BetaToolChoiceAuto { + type: 'auto'; + + /** + * Whether to disable parallel tool use. + * + * Defaults to `false`. If set to `true`, the model will output at most one tool + * use. + */ + disable_parallel_tool_use?: boolean; +} + +/** + * The model will not be allowed to use tools. + */ +export interface BetaToolChoiceNone { + type: 'none'; +} + +/** + * The model will use the specified tool with `tool_choice.name`. + */ +export interface BetaToolChoiceTool { + /** + * The name of the tool to use. + */ + name: string; + + type: 'tool'; + + /** + * Whether to disable parallel tool use. + * + * Defaults to `false`. If set to `true`, the model will output exactly one tool + * use. + */ + disable_parallel_tool_use?: boolean; +} + +export interface BetaToolComputerUse20241022 { + /** + * The height of the display in pixels. + */ + display_height_px: number; + + /** + * The width of the display in pixels. + */ + display_width_px: number; + + /** + * Name of the tool. + * + * This is how the tool will be called by the model and in `tool_use` blocks. + */ + name: 'computer'; + + type: 'computer_20241022'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; + + /** + * The X11 display number (e.g. 0, 1) for the display. + */ + display_number?: number | null; +} + +export interface BetaToolComputerUse20250124 { + /** + * The height of the display in pixels. + */ + display_height_px: number; + + /** + * The width of the display in pixels. + */ + display_width_px: number; + + /** + * Name of the tool. + * + * This is how the tool will be called by the model and in `tool_use` blocks. + */ + name: 'computer'; + + type: 'computer_20250124'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; + + /** + * The X11 display number (e.g. 0, 1) for the display. + */ + display_number?: number | null; +} + +export interface BetaToolResultBlockParam { + tool_use_id: string; + + type: 'tool_result'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; + + content?: string | Array; + + is_error?: boolean; +} + +export interface BetaToolTextEditor20241022 { + /** + * Name of the tool. + * + * This is how the tool will be called by the model and in `tool_use` blocks. + */ + name: 'str_replace_editor'; + + type: 'text_editor_20241022'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; +} + +export interface BetaToolTextEditor20250124 { + /** + * Name of the tool. + * + * This is how the tool will be called by the model and in `tool_use` blocks. + */ + name: 'str_replace_editor'; + + type: 'text_editor_20250124'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; +} + +export interface BetaToolTextEditor20250429 { + /** + * Name of the tool. + * + * This is how the tool will be called by the model and in `tool_use` blocks. + */ + name: 'str_replace_based_edit_tool'; + + type: 'text_editor_20250429'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; +} + +export type BetaToolUnion = + | BetaTool + | BetaToolBash20241022 + | BetaToolBash20250124 + | BetaCodeExecutionTool20250522 + | BetaToolComputerUse20241022 + | BetaToolComputerUse20250124 + | BetaToolTextEditor20241022 + | BetaToolTextEditor20250124 + | BetaToolTextEditor20250429 + | BetaWebSearchTool20250305; + +export interface BetaToolUseBlock { + id: string; + + input: unknown; + + name: string; + + type: 'tool_use'; +} + +export interface BetaToolUseBlockParam { + id: string; + + input: unknown; + + name: string; + + type: 'tool_use'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; +} + +export interface BetaURLImageSource { + type: 'url'; + + url: string; +} + +export interface BetaURLPDFSource { + type: 'url'; + + url: string; +} + +export interface BetaUsage { + /** + * Breakdown of cached tokens by TTL + */ + cache_creation: BetaCacheCreation | null; + + /** + * The number of input tokens used to create the cache entry. + */ + cache_creation_input_tokens: number | null; + + /** + * The number of input tokens read from the cache. + */ + cache_read_input_tokens: number | null; + + /** + * The number of input tokens which were used. + */ + input_tokens: number; + + /** + * The number of output tokens which were used. + */ + output_tokens: number; + + /** + * The number of server tool requests. + */ + server_tool_use: BetaServerToolUsage | null; + + /** + * If the request used the priority, standard, or batch tier. + */ + service_tier: 'standard' | 'priority' | 'batch' | null; +} + +export interface BetaWebSearchResultBlock { + encrypted_content: string; + + page_age: string | null; + + title: string; + + type: 'web_search_result'; + + url: string; +} + +export interface BetaWebSearchResultBlockParam { + encrypted_content: string; + + title: string; + + type: 'web_search_result'; + + url: string; + + page_age?: string | null; +} + +export interface BetaWebSearchTool20250305 { + /** + * Name of the tool. + * + * This is how the tool will be called by the model and in `tool_use` blocks. + */ + name: 'web_search'; + + type: 'web_search_20250305'; + + /** + * If provided, only these domains will be included in results. Cannot be used + * alongside `blocked_domains`. + */ + allowed_domains?: Array | null; + + /** + * If provided, these domains will never appear in results. Cannot be used + * alongside `allowed_domains`. + */ + blocked_domains?: Array | null; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; + + /** + * Maximum number of times the tool can be used in the API request. + */ + max_uses?: number | null; + + /** + * Parameters for the user's location. Used to provide more relevant search + * results. + */ + user_location?: BetaWebSearchTool20250305.UserLocation | null; +} + +export namespace BetaWebSearchTool20250305 { + /** + * Parameters for the user's location. Used to provide more relevant search + * results. + */ + export interface UserLocation { + type: 'approximate'; + + /** + * The city of the user. + */ + city?: string | null; + + /** + * The two letter + * [ISO country code](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) of the + * user. + */ + country?: string | null; + + /** + * The region of the user. + */ + region?: string | null; + + /** + * The [IANA timezone](https://nodatime.org/TimeZones) of the user. + */ + timezone?: string | null; + } +} + +export interface BetaWebSearchToolRequestError { + error_code: BetaWebSearchToolResultErrorCode; + + type: 'web_search_tool_result_error'; +} + +export interface BetaWebSearchToolResultBlock { + content: BetaWebSearchToolResultBlockContent; + + tool_use_id: string; + + type: 'web_search_tool_result'; +} + +export type BetaWebSearchToolResultBlockContent = + | BetaWebSearchToolResultError + | Array; + +export interface BetaWebSearchToolResultBlockParam { + content: BetaWebSearchToolResultBlockParamContent; + + tool_use_id: string; + + type: 'web_search_tool_result'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: BetaCacheControlEphemeral | null; +} + +export type BetaWebSearchToolResultBlockParamContent = + | Array + | BetaWebSearchToolRequestError; + +export interface BetaWebSearchToolResultError { + error_code: BetaWebSearchToolResultErrorCode; + + type: 'web_search_tool_result_error'; +} + +export type BetaWebSearchToolResultErrorCode = + | 'invalid_tool_input' + | 'unavailable' + | 'max_uses_exceeded' + | 'too_many_requests' + | 'query_too_long'; + +/** + * @deprecated BetaRequestDocumentBlock should be used insated + */ +export type BetaBase64PDFBlock = BetaRequestDocumentBlock; + +export type MessageCreateParams = MessageCreateParamsNonStreaming | MessageCreateParamsStreaming; + +export interface MessageCreateParamsBase { + /** + * Body param: The maximum number of tokens to generate before stopping. + * + * Note that our models may stop _before_ reaching this maximum. This parameter + * only specifies the absolute maximum number of tokens to generate. + * + * Different models have different maximum values for this parameter. See + * [models](https://docs.anthropic.com/en/docs/models-overview) for details. + */ + max_tokens: number; + + /** + * Body param: Input messages. + * + * Our models are trained to operate on alternating `user` and `assistant` + * conversational turns. When creating a new `Message`, you specify the prior + * conversational turns with the `messages` parameter, and the model then generates + * the next `Message` in the conversation. Consecutive `user` or `assistant` turns + * in your request will be combined into a single turn. + * + * Each input message must be an object with a `role` and `content`. You can + * specify a single `user`-role message, or you can include multiple `user` and + * `assistant` messages. + * + * If the final message uses the `assistant` role, the response content will + * continue immediately from the content in that message. This can be used to + * constrain part of the model's response. + * + * Example with a single `user` message: + * + * ```json + * [{ "role": "user", "content": "Hello, Claude" }] + * ``` + * + * Example with multiple conversational turns: + * + * ```json + * [ + * { "role": "user", "content": "Hello there." }, + * { "role": "assistant", "content": "Hi, I'm Claude. How can I help you?" }, + * { "role": "user", "content": "Can you explain LLMs in plain English?" } + * ] + * ``` + * + * Example with a partially-filled response from Claude: + * + * ```json + * [ + * { + * "role": "user", + * "content": "What's the Greek name for Sun? (A) Sol (B) Helios (C) Sun" + * }, + * { "role": "assistant", "content": "The best answer is (" } + * ] + * ``` + * + * Each input message `content` may be either a single `string` or an array of + * content blocks, where each block has a specific `type`. Using a `string` for + * `content` is shorthand for an array of one content block of type `"text"`. The + * following input messages are equivalent: + * + * ```json + * { "role": "user", "content": "Hello, Claude" } + * ``` + * + * ```json + * { "role": "user", "content": [{ "type": "text", "text": "Hello, Claude" }] } + * ``` + * + * Starting with Claude 3 models, you can also send image content blocks: + * + * ```json + * { + * "role": "user", + * "content": [ + * { + * "type": "image", + * "source": { + * "type": "base64", + * "media_type": "image/jpeg", + * "data": "/9j/4AAQSkZJRg..." + * } + * }, + * { "type": "text", "text": "What is in this image?" } + * ] + * } + * ``` + * + * We currently support the `base64` source type for images, and the `image/jpeg`, + * `image/png`, `image/gif`, and `image/webp` media types. + * + * See [examples](https://docs.anthropic.com/en/api/messages-examples#vision) for + * more input examples. + * + * Note that if you want to include a + * [system prompt](https://docs.anthropic.com/en/docs/system-prompts), you can use + * the top-level `system` parameter — there is no `"system"` role for input + * messages in the Messages API. + * + * There is a limit of 100,000 messages in a single request. + */ + messages: Array; + + /** + * Body param: The model that will complete your prompt.\n\nSee + * [models](https://docs.anthropic.com/en/docs/models-overview) for additional + * details and options. + */ + model: MessagesAPI.Model; + + /** + * Body param: Container identifier for reuse across requests. + */ + container?: string | null; + + /** + * Body param: MCP servers to be utilized in this request + */ + mcp_servers?: Array; + + /** + * Body param: An object describing metadata about the request. + */ + metadata?: BetaMetadata; + + /** + * Body param: Determines whether to use priority capacity (if available) or + * standard capacity for this request. + * + * Anthropic offers different levels of service for your API requests. See + * [service-tiers](https://docs.anthropic.com/en/api/service-tiers) for details. + */ + service_tier?: 'auto' | 'standard_only'; + + /** + * Body param: Custom text sequences that will cause the model to stop generating. + * + * Our models will normally stop when they have naturally completed their turn, + * which will result in a response `stop_reason` of `"end_turn"`. + * + * If you want the model to stop generating when it encounters custom strings of + * text, you can use the `stop_sequences` parameter. If the model encounters one of + * the custom sequences, the response `stop_reason` value will be `"stop_sequence"` + * and the response `stop_sequence` value will contain the matched stop sequence. + */ + stop_sequences?: Array; + + /** + * Body param: Whether to incrementally stream the response using server-sent + * events. + * + * See [streaming](https://docs.anthropic.com/en/api/messages-streaming) for + * details. + */ + stream?: boolean; + + /** + * Body param: System prompt. + * + * A system prompt is a way of providing context and instructions to Claude, such + * as specifying a particular goal or role. See our + * [guide to system prompts](https://docs.anthropic.com/en/docs/system-prompts). + */ + system?: string | Array; + + /** + * Body param: Amount of randomness injected into the response. + * + * Defaults to `1.0`. Ranges from `0.0` to `1.0`. Use `temperature` closer to `0.0` + * for analytical / multiple choice, and closer to `1.0` for creative and + * generative tasks. + * + * Note that even with `temperature` of `0.0`, the results will not be fully + * deterministic. + */ + temperature?: number; + + /** + * Body param: Configuration for enabling Claude's extended thinking. + * + * When enabled, responses include `thinking` content blocks showing Claude's + * thinking process before the final answer. Requires a minimum budget of 1,024 + * tokens and counts towards your `max_tokens` limit. + * + * See + * [extended thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking) + * for details. + */ + thinking?: BetaThinkingConfigParam; + + /** + * Body param: How the model should use the provided tools. The model can use a + * specific tool, any available tool, decide by itself, or not use tools at all. + */ + tool_choice?: BetaToolChoice; + + /** + * Body param: Definitions of tools that the model may use. + * + * If you include `tools` in your API request, the model may return `tool_use` + * content blocks that represent the model's use of those tools. You can then run + * those tools using the tool input generated by the model and then optionally + * return results back to the model using `tool_result` content blocks. + * + * There are two types of tools: **client tools** and **server tools**. The + * behavior described below applies to client tools. For + * [server tools](https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/overview#server-tools), + * see their individual documentation as each has its own behavior (e.g., the + * [web search tool](https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/web-search-tool)). + * + * Each tool definition includes: + * + * - `name`: Name of the tool. + * - `description`: Optional, but strongly-recommended description of the tool. + * - `input_schema`: [JSON schema](https://json-schema.org/draft/2020-12) for the + * tool `input` shape that the model will produce in `tool_use` output content + * blocks. + * + * For example, if you defined `tools` as: + * + * ```json + * [ + * { + * "name": "get_stock_price", + * "description": "Get the current stock price for a given ticker symbol.", + * "input_schema": { + * "type": "object", + * "properties": { + * "ticker": { + * "type": "string", + * "description": "The stock ticker symbol, e.g. AAPL for Apple Inc." + * } + * }, + * "required": ["ticker"] + * } + * } + * ] + * ``` + * + * And then asked the model "What's the S&P 500 at today?", the model might produce + * `tool_use` content blocks in the response like this: + * + * ```json + * [ + * { + * "type": "tool_use", + * "id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV", + * "name": "get_stock_price", + * "input": { "ticker": "^GSPC" } + * } + * ] + * ``` + * + * You might then run your `get_stock_price` tool with `{"ticker": "^GSPC"}` as an + * input, and return the following back to the model in a subsequent `user` + * message: + * + * ```json + * [ + * { + * "type": "tool_result", + * "tool_use_id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV", + * "content": "259.75 USD" + * } + * ] + * ``` + * + * Tools can be used for workflows that include running client-side tools and + * functions, or more generally whenever you want the model to produce a particular + * JSON structure of output. + * + * See our [guide](https://docs.anthropic.com/en/docs/tool-use) for more details. + */ + tools?: Array; + + /** + * Body param: Only sample from the top K options for each subsequent token. + * + * Used to remove "long tail" low probability responses. + * [Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277). + * + * Recommended for advanced use cases only. You usually only need to use + * `temperature`. + */ + top_k?: number; + + /** + * Body param: Use nucleus sampling. + * + * In nucleus sampling, we compute the cumulative distribution over all the options + * for each subsequent token in decreasing probability order and cut it off once it + * reaches a particular probability specified by `top_p`. You should either alter + * `temperature` or `top_p`, but not both. + * + * Recommended for advanced use cases only. You usually only need to use + * `temperature`. + */ + top_p?: number; + + /** + * Header param: Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export namespace MessageCreateParams { + export type MessageCreateParamsNonStreaming = MessagesMessagesAPI.MessageCreateParamsNonStreaming; + export type MessageCreateParamsStreaming = MessagesMessagesAPI.MessageCreateParamsStreaming; +} + +export interface MessageCreateParamsNonStreaming extends MessageCreateParamsBase { + /** + * Body param: Whether to incrementally stream the response using server-sent + * events. + * + * See [streaming](https://docs.anthropic.com/en/api/messages-streaming) for + * details. + */ + stream?: false; +} + +export interface MessageCreateParamsStreaming extends MessageCreateParamsBase { + /** + * Body param: Whether to incrementally stream the response using server-sent + * events. + * + * See [streaming](https://docs.anthropic.com/en/api/messages-streaming) for + * details. + */ + stream: true; +} + +export interface MessageCountTokensParams { + /** + * Body param: Input messages. + * + * Our models are trained to operate on alternating `user` and `assistant` + * conversational turns. When creating a new `Message`, you specify the prior + * conversational turns with the `messages` parameter, and the model then generates + * the next `Message` in the conversation. Consecutive `user` or `assistant` turns + * in your request will be combined into a single turn. + * + * Each input message must be an object with a `role` and `content`. You can + * specify a single `user`-role message, or you can include multiple `user` and + * `assistant` messages. + * + * If the final message uses the `assistant` role, the response content will + * continue immediately from the content in that message. This can be used to + * constrain part of the model's response. + * + * Example with a single `user` message: + * + * ```json + * [{ "role": "user", "content": "Hello, Claude" }] + * ``` + * + * Example with multiple conversational turns: + * + * ```json + * [ + * { "role": "user", "content": "Hello there." }, + * { "role": "assistant", "content": "Hi, I'm Claude. How can I help you?" }, + * { "role": "user", "content": "Can you explain LLMs in plain English?" } + * ] + * ``` + * + * Example with a partially-filled response from Claude: + * + * ```json + * [ + * { + * "role": "user", + * "content": "What's the Greek name for Sun? (A) Sol (B) Helios (C) Sun" + * }, + * { "role": "assistant", "content": "The best answer is (" } + * ] + * ``` + * + * Each input message `content` may be either a single `string` or an array of + * content blocks, where each block has a specific `type`. Using a `string` for + * `content` is shorthand for an array of one content block of type `"text"`. The + * following input messages are equivalent: + * + * ```json + * { "role": "user", "content": "Hello, Claude" } + * ``` + * + * ```json + * { "role": "user", "content": [{ "type": "text", "text": "Hello, Claude" }] } + * ``` + * + * Starting with Claude 3 models, you can also send image content blocks: + * + * ```json + * { + * "role": "user", + * "content": [ + * { + * "type": "image", + * "source": { + * "type": "base64", + * "media_type": "image/jpeg", + * "data": "/9j/4AAQSkZJRg..." + * } + * }, + * { "type": "text", "text": "What is in this image?" } + * ] + * } + * ``` + * + * We currently support the `base64` source type for images, and the `image/jpeg`, + * `image/png`, `image/gif`, and `image/webp` media types. + * + * See [examples](https://docs.anthropic.com/en/api/messages-examples#vision) for + * more input examples. + * + * Note that if you want to include a + * [system prompt](https://docs.anthropic.com/en/docs/system-prompts), you can use + * the top-level `system` parameter — there is no `"system"` role for input + * messages in the Messages API. + * + * There is a limit of 100,000 messages in a single request. + */ + messages: Array; + + /** + * Body param: The model that will complete your prompt.\n\nSee + * [models](https://docs.anthropic.com/en/docs/models-overview) for additional + * details and options. + */ + model: MessagesAPI.Model; + + /** + * Body param: MCP servers to be utilized in this request + */ + mcp_servers?: Array; + + /** + * Body param: System prompt. + * + * A system prompt is a way of providing context and instructions to Claude, such + * as specifying a particular goal or role. See our + * [guide to system prompts](https://docs.anthropic.com/en/docs/system-prompts). + */ + system?: string | Array; + + /** + * Body param: Configuration for enabling Claude's extended thinking. + * + * When enabled, responses include `thinking` content blocks showing Claude's + * thinking process before the final answer. Requires a minimum budget of 1,024 + * tokens and counts towards your `max_tokens` limit. + * + * See + * [extended thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking) + * for details. + */ + thinking?: BetaThinkingConfigParam; + + /** + * Body param: How the model should use the provided tools. The model can use a + * specific tool, any available tool, decide by itself, or not use tools at all. + */ + tool_choice?: BetaToolChoice; + + /** + * Body param: Definitions of tools that the model may use. + * + * If you include `tools` in your API request, the model may return `tool_use` + * content blocks that represent the model's use of those tools. You can then run + * those tools using the tool input generated by the model and then optionally + * return results back to the model using `tool_result` content blocks. + * + * There are two types of tools: **client tools** and **server tools**. The + * behavior described below applies to client tools. For + * [server tools](https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/overview#server-tools), + * see their individual documentation as each has its own behavior (e.g., the + * [web search tool](https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/web-search-tool)). + * + * Each tool definition includes: + * + * - `name`: Name of the tool. + * - `description`: Optional, but strongly-recommended description of the tool. + * - `input_schema`: [JSON schema](https://json-schema.org/draft/2020-12) for the + * tool `input` shape that the model will produce in `tool_use` output content + * blocks. + * + * For example, if you defined `tools` as: + * + * ```json + * [ + * { + * "name": "get_stock_price", + * "description": "Get the current stock price for a given ticker symbol.", + * "input_schema": { + * "type": "object", + * "properties": { + * "ticker": { + * "type": "string", + * "description": "The stock ticker symbol, e.g. AAPL for Apple Inc." + * } + * }, + * "required": ["ticker"] + * } + * } + * ] + * ``` + * + * And then asked the model "What's the S&P 500 at today?", the model might produce + * `tool_use` content blocks in the response like this: + * + * ```json + * [ + * { + * "type": "tool_use", + * "id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV", + * "name": "get_stock_price", + * "input": { "ticker": "^GSPC" } + * } + * ] + * ``` + * + * You might then run your `get_stock_price` tool with `{"ticker": "^GSPC"}` as an + * input, and return the following back to the model in a subsequent `user` + * message: + * + * ```json + * [ + * { + * "type": "tool_result", + * "tool_use_id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV", + * "content": "259.75 USD" + * } + * ] + * ``` + * + * Tools can be used for workflows that include running client-side tools and + * functions, or more generally whenever you want the model to produce a particular + * JSON structure of output. + * + * See our [guide](https://docs.anthropic.com/en/docs/tool-use) for more details. + */ + tools?: Array< + | BetaTool + | BetaToolBash20241022 + | BetaToolBash20250124 + | BetaCodeExecutionTool20250522 + | BetaToolComputerUse20241022 + | BetaToolComputerUse20250124 + | BetaToolTextEditor20241022 + | BetaToolTextEditor20250124 + | BetaToolTextEditor20250429 + | BetaWebSearchTool20250305 + >; + + /** + * Header param: Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +Messages.Batches = Batches; + +export declare namespace Messages { + export { + type BetaBase64ImageSource as BetaBase64ImageSource, + type BetaBase64PDFSource as BetaBase64PDFSource, + type BetaCacheControlEphemeral as BetaCacheControlEphemeral, + type BetaCacheCreation as BetaCacheCreation, + type BetaCitationCharLocation as BetaCitationCharLocation, + type BetaCitationCharLocationParam as BetaCitationCharLocationParam, + type BetaCitationContentBlockLocation as BetaCitationContentBlockLocation, + type BetaCitationContentBlockLocationParam as BetaCitationContentBlockLocationParam, + type BetaCitationPageLocation as BetaCitationPageLocation, + type BetaCitationPageLocationParam as BetaCitationPageLocationParam, + type BetaCitationSearchResultLocation as BetaCitationSearchResultLocation, + type BetaCitationSearchResultLocationParam as BetaCitationSearchResultLocationParam, + type BetaCitationWebSearchResultLocationParam as BetaCitationWebSearchResultLocationParam, + type BetaCitationsConfigParam as BetaCitationsConfigParam, + type BetaCitationsDelta as BetaCitationsDelta, + type BetaCitationsWebSearchResultLocation as BetaCitationsWebSearchResultLocation, + type BetaCodeExecutionOutputBlock as BetaCodeExecutionOutputBlock, + type BetaCodeExecutionOutputBlockParam as BetaCodeExecutionOutputBlockParam, + type BetaCodeExecutionResultBlock as BetaCodeExecutionResultBlock, + type BetaCodeExecutionResultBlockParam as BetaCodeExecutionResultBlockParam, + type BetaCodeExecutionTool20250522 as BetaCodeExecutionTool20250522, + type BetaCodeExecutionToolResultBlock as BetaCodeExecutionToolResultBlock, + type BetaCodeExecutionToolResultBlockContent as BetaCodeExecutionToolResultBlockContent, + type BetaCodeExecutionToolResultBlockParam as BetaCodeExecutionToolResultBlockParam, + type BetaCodeExecutionToolResultBlockParamContent as BetaCodeExecutionToolResultBlockParamContent, + type BetaCodeExecutionToolResultError as BetaCodeExecutionToolResultError, + type BetaCodeExecutionToolResultErrorCode as BetaCodeExecutionToolResultErrorCode, + type BetaCodeExecutionToolResultErrorParam as BetaCodeExecutionToolResultErrorParam, + type BetaContainer as BetaContainer, + type BetaContainerUploadBlock as BetaContainerUploadBlock, + type BetaContainerUploadBlockParam as BetaContainerUploadBlockParam, + type BetaContentBlock as BetaContentBlock, + type BetaContentBlockParam as BetaContentBlockParam, + type BetaContentBlockSource as BetaContentBlockSource, + type BetaContentBlockSourceContent as BetaContentBlockSourceContent, + type BetaFileDocumentSource as BetaFileDocumentSource, + type BetaFileImageSource as BetaFileImageSource, + type BetaImageBlockParam as BetaImageBlockParam, + type BetaInputJSONDelta as BetaInputJSONDelta, + type BetaMCPToolResultBlock as BetaMCPToolResultBlock, + type BetaMCPToolUseBlock as BetaMCPToolUseBlock, + type BetaMCPToolUseBlockParam as BetaMCPToolUseBlockParam, + type BetaMessage as BetaMessage, + type BetaMessageDeltaUsage as BetaMessageDeltaUsage, + type BetaMessageParam as BetaMessageParam, + type BetaMessageTokensCount as BetaMessageTokensCount, + type BetaMetadata as BetaMetadata, + type BetaPlainTextSource as BetaPlainTextSource, + type BetaRawContentBlockDelta as BetaRawContentBlockDelta, + type BetaRawContentBlockDeltaEvent as BetaRawContentBlockDeltaEvent, + type BetaRawContentBlockStartEvent as BetaRawContentBlockStartEvent, + type BetaRawContentBlockStopEvent as BetaRawContentBlockStopEvent, + type BetaRawMessageDeltaEvent as BetaRawMessageDeltaEvent, + type BetaRawMessageStartEvent as BetaRawMessageStartEvent, + type BetaRawMessageStopEvent as BetaRawMessageStopEvent, + type BetaRawMessageStreamEvent as BetaRawMessageStreamEvent, + type BetaRedactedThinkingBlock as BetaRedactedThinkingBlock, + type BetaRedactedThinkingBlockParam as BetaRedactedThinkingBlockParam, + type BetaRequestDocumentBlock as BetaRequestDocumentBlock, + type BetaRequestMCPServerToolConfiguration as BetaRequestMCPServerToolConfiguration, + type BetaRequestMCPServerURLDefinition as BetaRequestMCPServerURLDefinition, + type BetaRequestMCPToolResultBlockParam as BetaRequestMCPToolResultBlockParam, + type BetaSearchResultBlockParam as BetaSearchResultBlockParam, + type BetaServerToolUsage as BetaServerToolUsage, + type BetaServerToolUseBlock as BetaServerToolUseBlock, + type BetaServerToolUseBlockParam as BetaServerToolUseBlockParam, + type BetaSignatureDelta as BetaSignatureDelta, + type BetaStopReason as BetaStopReason, + type BetaTextBlock as BetaTextBlock, + type BetaTextBlockParam as BetaTextBlockParam, + type BetaTextCitation as BetaTextCitation, + type BetaTextCitationParam as BetaTextCitationParam, + type BetaTextDelta as BetaTextDelta, + type BetaThinkingBlock as BetaThinkingBlock, + type BetaThinkingBlockParam as BetaThinkingBlockParam, + type BetaThinkingConfigDisabled as BetaThinkingConfigDisabled, + type BetaThinkingConfigEnabled as BetaThinkingConfigEnabled, + type BetaThinkingConfigParam as BetaThinkingConfigParam, + type BetaThinkingDelta as BetaThinkingDelta, + type BetaTool as BetaTool, + type BetaToolBash20241022 as BetaToolBash20241022, + type BetaToolBash20250124 as BetaToolBash20250124, + type BetaToolChoice as BetaToolChoice, + type BetaToolChoiceAny as BetaToolChoiceAny, + type BetaToolChoiceAuto as BetaToolChoiceAuto, + type BetaToolChoiceNone as BetaToolChoiceNone, + type BetaToolChoiceTool as BetaToolChoiceTool, + type BetaToolComputerUse20241022 as BetaToolComputerUse20241022, + type BetaToolComputerUse20250124 as BetaToolComputerUse20250124, + type BetaToolResultBlockParam as BetaToolResultBlockParam, + type BetaToolTextEditor20241022 as BetaToolTextEditor20241022, + type BetaToolTextEditor20250124 as BetaToolTextEditor20250124, + type BetaToolTextEditor20250429 as BetaToolTextEditor20250429, + type BetaToolUnion as BetaToolUnion, + type BetaToolUseBlock as BetaToolUseBlock, + type BetaToolUseBlockParam as BetaToolUseBlockParam, + type BetaURLImageSource as BetaURLImageSource, + type BetaURLPDFSource as BetaURLPDFSource, + type BetaUsage as BetaUsage, + type BetaWebSearchResultBlock as BetaWebSearchResultBlock, + type BetaWebSearchResultBlockParam as BetaWebSearchResultBlockParam, + type BetaWebSearchTool20250305 as BetaWebSearchTool20250305, + type BetaWebSearchToolRequestError as BetaWebSearchToolRequestError, + type BetaWebSearchToolResultBlock as BetaWebSearchToolResultBlock, + type BetaWebSearchToolResultBlockContent as BetaWebSearchToolResultBlockContent, + type BetaWebSearchToolResultBlockParam as BetaWebSearchToolResultBlockParam, + type BetaWebSearchToolResultBlockParamContent as BetaWebSearchToolResultBlockParamContent, + type BetaWebSearchToolResultError as BetaWebSearchToolResultError, + type BetaWebSearchToolResultErrorCode as BetaWebSearchToolResultErrorCode, + type BetaBase64PDFBlock as BetaBase64PDFBlock, + type MessageCreateParams as MessageCreateParams, + type MessageCreateParamsNonStreaming as MessageCreateParamsNonStreaming, + type MessageCreateParamsStreaming as MessageCreateParamsStreaming, + type MessageCountTokensParams as MessageCountTokensParams, + }; + + export { + Batches as Batches, + type BetaDeletedMessageBatch as BetaDeletedMessageBatch, + type BetaMessageBatch as BetaMessageBatch, + type BetaMessageBatchCanceledResult as BetaMessageBatchCanceledResult, + type BetaMessageBatchErroredResult as BetaMessageBatchErroredResult, + type BetaMessageBatchExpiredResult as BetaMessageBatchExpiredResult, + type BetaMessageBatchIndividualResponse as BetaMessageBatchIndividualResponse, + type BetaMessageBatchRequestCounts as BetaMessageBatchRequestCounts, + type BetaMessageBatchResult as BetaMessageBatchResult, + type BetaMessageBatchSucceededResult as BetaMessageBatchSucceededResult, + type BetaMessageBatchesPage as BetaMessageBatchesPage, + type BatchCreateParams as BatchCreateParams, + type BatchRetrieveParams as BatchRetrieveParams, + type BatchListParams as BatchListParams, + type BatchDeleteParams as BatchDeleteParams, + type BatchCancelParams as BatchCancelParams, + type BatchResultsParams as BatchResultsParams, + }; +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/models.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/models.ts new file mode 100644 index 0000000000000000000000000000000000000000..94473d3898e2d5c8c3ffbadcd698c7d5ceb552c0 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/beta/models.ts @@ -0,0 +1,118 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import { APIResource } from '../../core/resource'; +import * as BetaAPI from './beta'; +import { APIPromise } from '../../core/api-promise'; +import { Page, type PageParams, PagePromise } from '../../core/pagination'; +import { buildHeaders } from '../../internal/headers'; +import { RequestOptions } from '../../internal/request-options'; +import { path } from '../../internal/utils/path'; + +export class Models extends APIResource { + /** + * Get a specific model. + * + * The Models API response can be used to determine information about a specific + * model or resolve a model alias to a model ID. + * + * @example + * ```ts + * const betaModelInfo = await client.beta.models.retrieve( + * 'model_id', + * ); + * ``` + */ + retrieve( + modelID: string, + params: ModelRetrieveParams | null | undefined = {}, + options?: RequestOptions, + ): APIPromise { + const { betas } = params ?? {}; + return this._client.get(path`/v1/models/${modelID}?beta=true`, { + ...options, + headers: buildHeaders([ + { ...(betas?.toString() != null ? { 'anthropic-beta': betas?.toString() } : undefined) }, + options?.headers, + ]), + }); + } + + /** + * List available models. + * + * The Models API response can be used to determine which models are available for + * use in the API. More recently released models are listed first. + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const betaModelInfo of client.beta.models.list()) { + * // ... + * } + * ``` + */ + list( + params: ModelListParams | null | undefined = {}, + options?: RequestOptions, + ): PagePromise { + const { betas, ...query } = params ?? {}; + return this._client.getAPIList('/v1/models?beta=true', Page, { + query, + ...options, + headers: buildHeaders([ + { ...(betas?.toString() != null ? { 'anthropic-beta': betas?.toString() } : undefined) }, + options?.headers, + ]), + }); + } +} + +export type BetaModelInfosPage = Page; + +export interface BetaModelInfo { + /** + * Unique model identifier. + */ + id: string; + + /** + * RFC 3339 datetime string representing the time at which the model was released. + * May be set to an epoch value if the release date is unknown. + */ + created_at: string; + + /** + * A human-readable name for the model. + */ + display_name: string; + + /** + * Object type. + * + * For Models, this is always `"model"`. + */ + type: 'model'; +} + +export interface ModelRetrieveParams { + /** + * Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export interface ModelListParams extends PageParams { + /** + * Header param: Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export declare namespace Models { + export { + type BetaModelInfo as BetaModelInfo, + type BetaModelInfosPage as BetaModelInfosPage, + type ModelRetrieveParams as ModelRetrieveParams, + type ModelListParams as ModelListParams, + }; +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/completions.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/completions.ts new file mode 100644 index 0000000000000000000000000000000000000000..fc52a9ff11410be496eaaa2a8bc2cc927a433075 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/completions.ts @@ -0,0 +1,231 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import { APIResource } from '../core/resource'; +import * as CompletionsAPI from './completions'; +import * as BetaAPI from './beta/beta'; +import * as MessagesAPI from './messages/messages'; +import { APIPromise } from '../core/api-promise'; +import { Stream } from '../core/streaming'; +import { buildHeaders } from '../internal/headers'; +import { RequestOptions } from '../internal/request-options'; + +export class Completions extends APIResource { + /** + * [Legacy] Create a Text Completion. + * + * The Text Completions API is a legacy API. We recommend using the + * [Messages API](https://docs.anthropic.com/en/api/messages) going forward. + * + * Future models and features will not be compatible with Text Completions. See our + * [migration guide](https://docs.anthropic.com/en/api/migrating-from-text-completions-to-messages) + * for guidance in migrating from Text Completions to Messages. + * + * @example + * ```ts + * const completion = await client.completions.create({ + * max_tokens_to_sample: 256, + * model: 'claude-3-7-sonnet-latest', + * prompt: '\n\nHuman: Hello, world!\n\nAssistant:', + * }); + * ``` + */ + create(params: CompletionCreateParamsNonStreaming, options?: RequestOptions): APIPromise; + create(params: CompletionCreateParamsStreaming, options?: RequestOptions): APIPromise>; + create( + params: CompletionCreateParamsBase, + options?: RequestOptions, + ): APIPromise | Completion>; + create( + params: CompletionCreateParams, + options?: RequestOptions, + ): APIPromise | APIPromise> { + const { betas, ...body } = params; + return this._client.post('/v1/complete', { + body, + timeout: (this._client as any)._options.timeout ?? 600000, + ...options, + headers: buildHeaders([ + { ...(betas?.toString() != null ? { 'anthropic-beta': betas?.toString() } : undefined) }, + options?.headers, + ]), + stream: params.stream ?? false, + }) as APIPromise | APIPromise>; + } +} + +export interface Completion { + /** + * Unique object identifier. + * + * The format and length of IDs may change over time. + */ + id: string; + + /** + * The resulting completion up to and excluding the stop sequences. + */ + completion: string; + + /** + * The model that will complete your prompt.\n\nSee + * [models](https://docs.anthropic.com/en/docs/models-overview) for additional + * details and options. + */ + model: MessagesAPI.Model; + + /** + * The reason that we stopped. + * + * This may be one the following values: + * + * - `"stop_sequence"`: we reached a stop sequence — either provided by you via the + * `stop_sequences` parameter, or a stop sequence built into the model + * - `"max_tokens"`: we exceeded `max_tokens_to_sample` or the model's maximum + */ + stop_reason: string | null; + + /** + * Object type. + * + * For Text Completions, this is always `"completion"`. + */ + type: 'completion'; +} + +export type CompletionCreateParams = CompletionCreateParamsNonStreaming | CompletionCreateParamsStreaming; + +export interface CompletionCreateParamsBase { + /** + * Body param: The maximum number of tokens to generate before stopping. + * + * Note that our models may stop _before_ reaching this maximum. This parameter + * only specifies the absolute maximum number of tokens to generate. + */ + max_tokens_to_sample: number; + + /** + * Body param: The model that will complete your prompt.\n\nSee + * [models](https://docs.anthropic.com/en/docs/models-overview) for additional + * details and options. + */ + model: MessagesAPI.Model; + + /** + * Body param: The prompt that you want Claude to complete. + * + * For proper response generation you will need to format your prompt using + * alternating `\n\nHuman:` and `\n\nAssistant:` conversational turns. For example: + * + * ``` + * "\n\nHuman: {userQuestion}\n\nAssistant:" + * ``` + * + * See [prompt validation](https://docs.anthropic.com/en/api/prompt-validation) and + * our guide to + * [prompt design](https://docs.anthropic.com/en/docs/intro-to-prompting) for more + * details. + */ + prompt: string; + + /** + * Body param: An object describing metadata about the request. + */ + metadata?: MessagesAPI.Metadata; + + /** + * Body param: Sequences that will cause the model to stop generating. + * + * Our models stop on `"\n\nHuman:"`, and may include additional built-in stop + * sequences in the future. By providing the stop_sequences parameter, you may + * include additional strings that will cause the model to stop generating. + */ + stop_sequences?: Array; + + /** + * Body param: Whether to incrementally stream the response using server-sent + * events. + * + * See [streaming](https://docs.anthropic.com/en/api/streaming) for details. + */ + stream?: boolean; + + /** + * Body param: Amount of randomness injected into the response. + * + * Defaults to `1.0`. Ranges from `0.0` to `1.0`. Use `temperature` closer to `0.0` + * for analytical / multiple choice, and closer to `1.0` for creative and + * generative tasks. + * + * Note that even with `temperature` of `0.0`, the results will not be fully + * deterministic. + */ + temperature?: number; + + /** + * Body param: Only sample from the top K options for each subsequent token. + * + * Used to remove "long tail" low probability responses. + * [Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277). + * + * Recommended for advanced use cases only. You usually only need to use + * `temperature`. + */ + top_k?: number; + + /** + * Body param: Use nucleus sampling. + * + * In nucleus sampling, we compute the cumulative distribution over all the options + * for each subsequent token in decreasing probability order and cut it off once it + * reaches a particular probability specified by `top_p`. You should either alter + * `temperature` or `top_p`, but not both. + * + * Recommended for advanced use cases only. You usually only need to use + * `temperature`. + */ + top_p?: number; + + /** + * Header param: Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export namespace CompletionCreateParams { + /** + * @deprecated use `Anthropic.Messages.Metadata` instead + */ + export type Metadata = MessagesAPI.Metadata; + + export type CompletionCreateParamsNonStreaming = CompletionsAPI.CompletionCreateParamsNonStreaming; + export type CompletionCreateParamsStreaming = CompletionsAPI.CompletionCreateParamsStreaming; +} + +export interface CompletionCreateParamsNonStreaming extends CompletionCreateParamsBase { + /** + * Body param: Whether to incrementally stream the response using server-sent + * events. + * + * See [streaming](https://docs.anthropic.com/en/api/streaming) for details. + */ + stream?: false; +} + +export interface CompletionCreateParamsStreaming extends CompletionCreateParamsBase { + /** + * Body param: Whether to incrementally stream the response using server-sent + * events. + * + * See [streaming](https://docs.anthropic.com/en/api/streaming) for details. + */ + stream: true; +} + +export declare namespace Completions { + export { + type Completion as Completion, + type CompletionCreateParams as CompletionCreateParams, + type CompletionCreateParamsNonStreaming as CompletionCreateParamsNonStreaming, + type CompletionCreateParamsStreaming as CompletionCreateParamsStreaming, + }; +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/index.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..1d3a88a356f117aaf97d8783b09a793c223a3cea --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/index.ts @@ -0,0 +1,121 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +export * from './shared'; +export { + Beta, + type AnthropicBeta, + type BetaAPIError, + type BetaAuthenticationError, + type BetaBillingError, + type BetaError, + type BetaErrorResponse, + type BetaGatewayTimeoutError, + type BetaInvalidRequestError, + type BetaNotFoundError, + type BetaOverloadedError, + type BetaPermissionError, + type BetaRateLimitError, +} from './beta/beta'; +export { + Completions, + type Completion, + type CompletionCreateParams, + type CompletionCreateParamsNonStreaming, + type CompletionCreateParamsStreaming, +} from './completions'; +export { + Messages, + type Base64ImageSource, + type Base64PDFSource, + type CacheControlEphemeral, + type CitationCharLocation, + type CitationCharLocationParam, + type CitationContentBlockLocation, + type CitationContentBlockLocationParam, + type CitationPageLocation, + type CitationPageLocationParam, + type CitationWebSearchResultLocationParam, + type CitationsConfigParam, + type CitationsDelta, + type CitationsWebSearchResultLocation, + type ContentBlock, + type ContentBlockParam, + type ContentBlockStartEvent, + type ContentBlockStopEvent, + type ContentBlockSource, + type ContentBlockSourceContent, + type DocumentBlockParam, + type ImageBlockParam, + type InputJSONDelta, + type Message, + type MessageCountTokensTool, + type MessageDeltaEvent, + type MessageDeltaUsage, + type MessageParam, + type MessageStreamParams, + type MessageTokensCount, + type Metadata, + type Model, + type PlainTextSource, + type RawContentBlockDelta, + type RawContentBlockDeltaEvent, + type RawContentBlockStartEvent, + type RawContentBlockStopEvent, + type RawMessageDeltaEvent, + type RawMessageStartEvent, + type RawMessageStopEvent, + type RawMessageStreamEvent, + type RedactedThinkingBlock, + type RedactedThinkingBlockParam, + type ServerToolUsage, + type ServerToolUseBlock, + type ServerToolUseBlockParam, + type SignatureDelta, + type StopReason, + type TextBlock, + type TextBlockParam, + type TextCitation, + type TextCitationParam, + type TextDelta, + type ThinkingBlock, + type ThinkingBlockParam, + type ThinkingConfigDisabled, + type ThinkingConfigEnabled, + type ThinkingConfigParam, + type ThinkingDelta, + type Tool, + type ToolBash20250124, + type ToolChoice, + type ToolChoiceAny, + type ToolChoiceAuto, + type ToolChoiceNone, + type ToolChoiceTool, + type ToolResultBlockParam, + type ToolTextEditor20250124, + type ToolUnion, + type ToolUseBlock, + type ToolUseBlockParam, + type URLImageSource, + type URLPDFSource, + type Usage, + type WebSearchResultBlock, + type WebSearchResultBlockParam, + type WebSearchTool20250305, + type WebSearchToolRequestError, + type WebSearchToolResultBlock, + type WebSearchToolResultBlockContent, + type WebSearchToolResultBlockParam, + type WebSearchToolResultBlockParamContent, + type WebSearchToolResultError, + type MessageCreateParams, + type MessageCreateParamsNonStreaming, + type MessageCreateParamsStreaming, + type MessageCountTokensParams, +} from './messages/messages'; +export { + Models, + type ModelInfo, + type ModelRetrieveParams, + type ModelListParams, + type ModelInfosPage, +} from './models'; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/messages.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/messages.ts new file mode 100644 index 0000000000000000000000000000000000000000..eb1752308f31e493534e505ff745085107f9d210 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/messages.ts @@ -0,0 +1,3 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +export * from './messages/index'; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/messages/batches.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/messages/batches.ts new file mode 100644 index 0000000000000000000000000000000000000000..1bd4ba5687b9ea6d5caf08f1f001a4cca844104d --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/messages/batches.ts @@ -0,0 +1,396 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import { APIResource } from '../../core/resource'; +import * as Shared from '../shared'; +import * as MessagesAPI from './messages'; +import { APIPromise } from '../../core/api-promise'; +import { Page, type PageParams, PagePromise } from '../../core/pagination'; +import { buildHeaders } from '../../internal/headers'; +import { RequestOptions } from '../../internal/request-options'; +import { JSONLDecoder } from '../../internal/decoders/jsonl'; +import { AnthropicError } from '../../error'; +import { path } from '../../internal/utils/path'; + +export class Batches extends APIResource { + /** + * Send a batch of Message creation requests. + * + * The Message Batches API can be used to process multiple Messages API requests at + * once. Once a Message Batch is created, it begins processing immediately. Batches + * can take up to 24 hours to complete. + * + * Learn more about the Message Batches API in our + * [user guide](/en/docs/build-with-claude/batch-processing) + * + * @example + * ```ts + * const messageBatch = await client.messages.batches.create({ + * requests: [ + * { + * custom_id: 'my-custom-id-1', + * params: { + * max_tokens: 1024, + * messages: [ + * { content: 'Hello, world', role: 'user' }, + * ], + * model: 'claude-sonnet-4-20250514', + * }, + * }, + * ], + * }); + * ``` + */ + create(body: BatchCreateParams, options?: RequestOptions): APIPromise { + return this._client.post('/v1/messages/batches', { body, ...options }); + } + + /** + * This endpoint is idempotent and can be used to poll for Message Batch + * completion. To access the results of a Message Batch, make a request to the + * `results_url` field in the response. + * + * Learn more about the Message Batches API in our + * [user guide](/en/docs/build-with-claude/batch-processing) + * + * @example + * ```ts + * const messageBatch = await client.messages.batches.retrieve( + * 'message_batch_id', + * ); + * ``` + */ + retrieve(messageBatchID: string, options?: RequestOptions): APIPromise { + return this._client.get(path`/v1/messages/batches/${messageBatchID}`, options); + } + + /** + * List all Message Batches within a Workspace. Most recently created batches are + * returned first. + * + * Learn more about the Message Batches API in our + * [user guide](/en/docs/build-with-claude/batch-processing) + * + * @example + * ```ts + * // Automatically fetches more pages as needed. + * for await (const messageBatch of client.messages.batches.list()) { + * // ... + * } + * ``` + */ + list( + query: BatchListParams | null | undefined = {}, + options?: RequestOptions, + ): PagePromise { + return this._client.getAPIList('/v1/messages/batches', Page, { query, ...options }); + } + + /** + * Delete a Message Batch. + * + * Message Batches can only be deleted once they've finished processing. If you'd + * like to delete an in-progress batch, you must first cancel it. + * + * Learn more about the Message Batches API in our + * [user guide](/en/docs/build-with-claude/batch-processing) + * + * @example + * ```ts + * const deletedMessageBatch = + * await client.messages.batches.delete('message_batch_id'); + * ``` + */ + delete(messageBatchID: string, options?: RequestOptions): APIPromise { + return this._client.delete(path`/v1/messages/batches/${messageBatchID}`, options); + } + + /** + * Batches may be canceled any time before processing ends. Once cancellation is + * initiated, the batch enters a `canceling` state, at which time the system may + * complete any in-progress, non-interruptible requests before finalizing + * cancellation. + * + * The number of canceled requests is specified in `request_counts`. To determine + * which requests were canceled, check the individual results within the batch. + * Note that cancellation may not result in any canceled requests if they were + * non-interruptible. + * + * Learn more about the Message Batches API in our + * [user guide](/en/docs/build-with-claude/batch-processing) + * + * @example + * ```ts + * const messageBatch = await client.messages.batches.cancel( + * 'message_batch_id', + * ); + * ``` + */ + cancel(messageBatchID: string, options?: RequestOptions): APIPromise { + return this._client.post(path`/v1/messages/batches/${messageBatchID}/cancel`, options); + } + + /** + * Streams the results of a Message Batch as a `.jsonl` file. + * + * Each line in the file is a JSON object containing the result of a single request + * in the Message Batch. Results are not guaranteed to be in the same order as + * requests. Use the `custom_id` field to match results to requests. + * + * Learn more about the Message Batches API in our + * [user guide](/en/docs/build-with-claude/batch-processing) + * + * @example + * ```ts + * const messageBatchIndividualResponse = + * await client.messages.batches.results('message_batch_id'); + * ``` + */ + async results( + messageBatchID: string, + options?: RequestOptions, + ): Promise> { + const batch = await this.retrieve(messageBatchID); + if (!batch.results_url) { + throw new AnthropicError( + `No batch \`results_url\`; Has it finished processing? ${batch.processing_status} - ${batch.id}`, + ); + } + + return this._client + .get(batch.results_url, { + ...options, + headers: buildHeaders([{ Accept: 'application/binary' }, options?.headers]), + stream: true, + __binaryResponse: true, + }) + ._thenUnwrap((_, props) => JSONLDecoder.fromResponse(props.response, props.controller)) as APIPromise< + JSONLDecoder + >; + } +} + +export type MessageBatchesPage = Page; + +export interface DeletedMessageBatch { + /** + * ID of the Message Batch. + */ + id: string; + + /** + * Deleted object type. + * + * For Message Batches, this is always `"message_batch_deleted"`. + */ + type: 'message_batch_deleted'; +} + +export interface MessageBatch { + /** + * Unique object identifier. + * + * The format and length of IDs may change over time. + */ + id: string; + + /** + * RFC 3339 datetime string representing the time at which the Message Batch was + * archived and its results became unavailable. + */ + archived_at: string | null; + + /** + * RFC 3339 datetime string representing the time at which cancellation was + * initiated for the Message Batch. Specified only if cancellation was initiated. + */ + cancel_initiated_at: string | null; + + /** + * RFC 3339 datetime string representing the time at which the Message Batch was + * created. + */ + created_at: string; + + /** + * RFC 3339 datetime string representing the time at which processing for the + * Message Batch ended. Specified only once processing ends. + * + * Processing ends when every request in a Message Batch has either succeeded, + * errored, canceled, or expired. + */ + ended_at: string | null; + + /** + * RFC 3339 datetime string representing the time at which the Message Batch will + * expire and end processing, which is 24 hours after creation. + */ + expires_at: string; + + /** + * Processing status of the Message Batch. + */ + processing_status: 'in_progress' | 'canceling' | 'ended'; + + /** + * Tallies requests within the Message Batch, categorized by their status. + * + * Requests start as `processing` and move to one of the other statuses only once + * processing of the entire batch ends. The sum of all values always matches the + * total number of requests in the batch. + */ + request_counts: MessageBatchRequestCounts; + + /** + * URL to a `.jsonl` file containing the results of the Message Batch requests. + * Specified only once processing ends. + * + * Results in the file are not guaranteed to be in the same order as requests. Use + * the `custom_id` field to match results to requests. + */ + results_url: string | null; + + /** + * Object type. + * + * For Message Batches, this is always `"message_batch"`. + */ + type: 'message_batch'; +} + +export interface MessageBatchCanceledResult { + type: 'canceled'; +} + +export interface MessageBatchErroredResult { + error: Shared.ErrorResponse; + + type: 'errored'; +} + +export interface MessageBatchExpiredResult { + type: 'expired'; +} + +/** + * This is a single line in the response `.jsonl` file and does not represent the + * response as a whole. + */ +export interface MessageBatchIndividualResponse { + /** + * Developer-provided ID created for each request in a Message Batch. Useful for + * matching results to requests, as results may be given out of request order. + * + * Must be unique for each request within the Message Batch. + */ + custom_id: string; + + /** + * Processing result for this request. + * + * Contains a Message output if processing was successful, an error response if + * processing failed, or the reason why processing was not attempted, such as + * cancellation or expiration. + */ + result: MessageBatchResult; +} + +export interface MessageBatchRequestCounts { + /** + * Number of requests in the Message Batch that have been canceled. + * + * This is zero until processing of the entire Message Batch has ended. + */ + canceled: number; + + /** + * Number of requests in the Message Batch that encountered an error. + * + * This is zero until processing of the entire Message Batch has ended. + */ + errored: number; + + /** + * Number of requests in the Message Batch that have expired. + * + * This is zero until processing of the entire Message Batch has ended. + */ + expired: number; + + /** + * Number of requests in the Message Batch that are processing. + */ + processing: number; + + /** + * Number of requests in the Message Batch that have completed successfully. + * + * This is zero until processing of the entire Message Batch has ended. + */ + succeeded: number; +} + +/** + * Processing result for this request. + * + * Contains a Message output if processing was successful, an error response if + * processing failed, or the reason why processing was not attempted, such as + * cancellation or expiration. + */ +export type MessageBatchResult = + | MessageBatchSucceededResult + | MessageBatchErroredResult + | MessageBatchCanceledResult + | MessageBatchExpiredResult; + +export interface MessageBatchSucceededResult { + message: MessagesAPI.Message; + + type: 'succeeded'; +} + +export interface BatchCreateParams { + /** + * List of requests for prompt completion. Each is an individual request to create + * a Message. + */ + requests: Array; +} + +export namespace BatchCreateParams { + export interface Request { + /** + * Developer-provided ID created for each request in a Message Batch. Useful for + * matching results to requests, as results may be given out of request order. + * + * Must be unique for each request within the Message Batch. + */ + custom_id: string; + + /** + * Messages API creation parameters for the individual request. + * + * See the [Messages API reference](/en/api/messages) for full documentation on + * available parameters. + */ + params: MessagesAPI.MessageCreateParamsNonStreaming; + } +} + +export interface BatchListParams extends PageParams {} + +export declare namespace Batches { + export { + type DeletedMessageBatch as DeletedMessageBatch, + type MessageBatch as MessageBatch, + type MessageBatchCanceledResult as MessageBatchCanceledResult, + type MessageBatchErroredResult as MessageBatchErroredResult, + type MessageBatchExpiredResult as MessageBatchExpiredResult, + type MessageBatchIndividualResponse as MessageBatchIndividualResponse, + type MessageBatchRequestCounts as MessageBatchRequestCounts, + type MessageBatchResult as MessageBatchResult, + type MessageBatchSucceededResult as MessageBatchSucceededResult, + type MessageBatchesPage as MessageBatchesPage, + type BatchCreateParams as BatchCreateParams, + type BatchListParams as BatchListParams, + }; +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/messages/index.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/messages/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..db7320ea7be03530aab9509eeb6cc4d8bc204e97 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/messages/index.ts @@ -0,0 +1,110 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +export { + Batches, + type DeletedMessageBatch, + type MessageBatch, + type MessageBatchCanceledResult, + type MessageBatchErroredResult, + type MessageBatchExpiredResult, + type MessageBatchIndividualResponse, + type MessageBatchRequestCounts, + type MessageBatchResult, + type MessageBatchSucceededResult, + type BatchCreateParams, + type BatchListParams, + type MessageBatchesPage, +} from './batches'; +export { + Messages, + type Base64ImageSource, + type Base64PDFSource, + type CacheControlEphemeral, + type CitationCharLocation, + type CitationCharLocationParam, + type CitationContentBlockLocation, + type CitationContentBlockLocationParam, + type CitationPageLocation, + type CitationPageLocationParam, + type CitationWebSearchResultLocationParam, + type CitationsConfigParam, + type CitationsDelta, + type CitationsWebSearchResultLocation, + type ContentBlock, + type ContentBlockParam, + type ContentBlockStartEvent, + type ContentBlockStopEvent, + type ContentBlockSource, + type ContentBlockSourceContent, + type DocumentBlockParam, + type ImageBlockParam, + type InputJSONDelta, + type Message, + type MessageCountTokensTool, + type MessageDeltaEvent, + type MessageDeltaUsage, + type MessageParam, + type MessageTokensCount, + type Metadata, + type Model, + type PlainTextSource, + type RawContentBlockDelta, + type RawContentBlockDeltaEvent, + type RawContentBlockStartEvent, + type RawContentBlockStopEvent, + type RawMessageDeltaEvent, + type RawMessageStartEvent, + type RawMessageStopEvent, + type RawMessageStreamEvent, + type RedactedThinkingBlock, + type RedactedThinkingBlockParam, + type ServerToolUsage, + type ServerToolUseBlock, + type ServerToolUseBlockParam, + type SignatureDelta, + type StopReason, + type TextBlock, + type TextBlockParam, + type TextCitation, + type TextCitationParam, + type TextDelta, + type ThinkingBlock, + type ThinkingBlockParam, + type ThinkingConfigDisabled, + type ThinkingConfigEnabled, + type ThinkingConfigParam, + type ThinkingDelta, + type Tool, + type ToolBash20250124, + type ToolChoice, + type ToolChoiceAny, + type ToolChoiceAuto, + type ToolChoiceNone, + type ToolChoiceTool, + type ToolResultBlockParam, + type ToolTextEditor20250124, + type ToolUnion, + type ToolUseBlock, + type ToolUseBlockParam, + type URLImageSource, + type URLPDFSource, + type Usage, + type WebSearchResultBlock, + type WebSearchResultBlockParam, + type WebSearchTool20250305, + type WebSearchToolRequestError, + type WebSearchToolResultBlock, + type WebSearchToolResultBlockContent, + type WebSearchToolResultBlockParam, + type WebSearchToolResultBlockParamContent, + type WebSearchToolResultError, + type MessageStreamEvent, + type MessageStartEvent, + type MessageStopEvent, + type ContentBlockDeltaEvent, + type MessageCreateParams, + type MessageCreateParamsBase, + type MessageCreateParamsNonStreaming, + type MessageCreateParamsStreaming, + type MessageCountTokensParams, +} from './messages'; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/messages/messages.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/messages/messages.ts new file mode 100644 index 0000000000000000000000000000000000000000..b7e03df5e21388955daf13614855f3b1360ea575 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/messages/messages.ts @@ -0,0 +1,1848 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import { APIPromise } from '../../core/api-promise'; +import { APIResource } from '../../core/resource'; +import { Stream } from '../../core/streaming'; +import { RequestOptions } from '../../internal/request-options'; +import { MessageStream } from '../../lib/MessageStream'; +import * as BatchesAPI from './batches'; +import { + BatchCreateParams, + BatchListParams, + Batches, + DeletedMessageBatch, + MessageBatch, + MessageBatchCanceledResult, + MessageBatchErroredResult, + MessageBatchExpiredResult, + MessageBatchIndividualResponse, + MessageBatchRequestCounts, + MessageBatchResult, + MessageBatchSucceededResult, + MessageBatchesPage, +} from './batches'; +import * as MessagesAPI from './messages'; + +import { MODEL_NONSTREAMING_TOKENS } from '../../internal/constants'; + +export class Messages extends APIResource { + batches: BatchesAPI.Batches = new BatchesAPI.Batches(this._client); + + /** + * Send a structured list of input messages with text and/or image content, and the + * model will generate the next message in the conversation. + * + * The Messages API can be used for either single queries or stateless multi-turn + * conversations. + * + * Learn more about the Messages API in our [user guide](/en/docs/initial-setup) + * + * @example + * ```ts + * const message = await client.messages.create({ + * max_tokens: 1024, + * messages: [{ content: 'Hello, world', role: 'user' }], + * model: 'claude-sonnet-4-20250514', + * }); + * ``` + */ + create(body: MessageCreateParamsNonStreaming, options?: RequestOptions): APIPromise; + create( + body: MessageCreateParamsStreaming, + options?: RequestOptions, + ): APIPromise>; + create( + body: MessageCreateParamsBase, + options?: RequestOptions, + ): APIPromise | Message>; + create( + body: MessageCreateParams, + options?: RequestOptions, + ): APIPromise | APIPromise> { + if (body.model in DEPRECATED_MODELS) { + console.warn( + `The model '${body.model}' is deprecated and will reach end-of-life on ${ + DEPRECATED_MODELS[body.model] + }\nPlease migrate to a newer model. Visit https://docs.anthropic.com/en/docs/resources/model-deprecations for more information.`, + ); + } + let timeout = (this._client as any)._options.timeout as number | null; + if (!body.stream && timeout == null) { + const maxNonstreamingTokens = MODEL_NONSTREAMING_TOKENS[body.model] ?? undefined; + timeout = this._client.calculateNonstreamingTimeout(body.max_tokens, maxNonstreamingTokens); + } + return this._client.post('/v1/messages', { + body, + timeout: timeout ?? 600000, + ...options, + stream: body.stream ?? false, + }) as APIPromise | APIPromise>; + } + + /** + * Create a Message stream + */ + stream(body: MessageStreamParams, options?: RequestOptions): MessageStream { + return MessageStream.createMessage(this, body, options); + } + + /** + * Count the number of tokens in a Message. + * + * The Token Count API can be used to count the number of tokens in a Message, + * including tools, images, and documents, without creating it. + * + * Learn more about token counting in our + * [user guide](/en/docs/build-with-claude/token-counting) + * + * @example + * ```ts + * const messageTokensCount = + * await client.messages.countTokens({ + * messages: [{ content: 'string', role: 'user' }], + * model: 'claude-3-7-sonnet-latest', + * }); + * ``` + */ + countTokens(body: MessageCountTokensParams, options?: RequestOptions): APIPromise { + return this._client.post('/v1/messages/count_tokens', { body, ...options }); + } +} + +export interface Base64ImageSource { + data: string; + + media_type: 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp'; + + type: 'base64'; +} + +export interface Base64PDFSource { + data: string; + + media_type: 'application/pdf'; + + type: 'base64'; +} + +export interface CacheControlEphemeral { + type: 'ephemeral'; +} + +export interface CitationCharLocation { + cited_text: string; + + document_index: number; + + document_title: string | null; + + end_char_index: number; + + start_char_index: number; + + type: 'char_location'; +} + +export interface CitationCharLocationParam { + cited_text: string; + + document_index: number; + + document_title: string | null; + + end_char_index: number; + + start_char_index: number; + + type: 'char_location'; +} + +export interface CitationContentBlockLocation { + cited_text: string; + + document_index: number; + + document_title: string | null; + + end_block_index: number; + + start_block_index: number; + + type: 'content_block_location'; +} + +export interface CitationContentBlockLocationParam { + cited_text: string; + + document_index: number; + + document_title: string | null; + + end_block_index: number; + + start_block_index: number; + + type: 'content_block_location'; +} + +export interface CitationPageLocation { + cited_text: string; + + document_index: number; + + document_title: string | null; + + end_page_number: number; + + start_page_number: number; + + type: 'page_location'; +} + +export interface CitationPageLocationParam { + cited_text: string; + + document_index: number; + + document_title: string | null; + + end_page_number: number; + + start_page_number: number; + + type: 'page_location'; +} + +export interface CitationWebSearchResultLocationParam { + cited_text: string; + + encrypted_index: string; + + title: string | null; + + type: 'web_search_result_location'; + + url: string; +} + +export interface CitationsConfigParam { + enabled?: boolean; +} + +export interface CitationsDelta { + citation: + | CitationCharLocation + | CitationPageLocation + | CitationContentBlockLocation + | CitationsWebSearchResultLocation; + + type: 'citations_delta'; +} + +export interface CitationsWebSearchResultLocation { + cited_text: string; + + encrypted_index: string; + + title: string | null; + + type: 'web_search_result_location'; + + url: string; +} + +export type ContentBlock = + | TextBlock + | ThinkingBlock + | RedactedThinkingBlock + | ToolUseBlock + | ServerToolUseBlock + | WebSearchToolResultBlock; + +/** + * Regular text content. + */ +export type ContentBlockParam = + | TextBlockParam + | ImageBlockParam + | DocumentBlockParam + | ThinkingBlockParam + | RedactedThinkingBlockParam + | ToolUseBlockParam + | ToolResultBlockParam + | ServerToolUseBlockParam + | WebSearchToolResultBlockParam; + +export interface ContentBlockSource { + content: string | Array; + + type: 'content'; +} + +export type ContentBlockSourceContent = TextBlockParam | ImageBlockParam; + +export interface DocumentBlockParam { + source: Base64PDFSource | PlainTextSource | ContentBlockSource | URLPDFSource; + + type: 'document'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: CacheControlEphemeral | null; + + citations?: CitationsConfigParam; + + context?: string | null; + + title?: string | null; +} + +export interface ImageBlockParam { + source: Base64ImageSource | URLImageSource; + + type: 'image'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: CacheControlEphemeral | null; +} + +export interface InputJSONDelta { + partial_json: string; + + type: 'input_json_delta'; +} + +export interface Message { + /** + * Unique object identifier. + * + * The format and length of IDs may change over time. + */ + id: string; + + /** + * Content generated by the model. + * + * This is an array of content blocks, each of which has a `type` that determines + * its shape. + * + * Example: + * + * ```json + * [{ "type": "text", "text": "Hi, I'm Claude." }] + * ``` + * + * If the request input `messages` ended with an `assistant` turn, then the + * response `content` will continue directly from that last turn. You can use this + * to constrain the model's output. + * + * For example, if the input `messages` were: + * + * ```json + * [ + * { + * "role": "user", + * "content": "What's the Greek name for Sun? (A) Sol (B) Helios (C) Sun" + * }, + * { "role": "assistant", "content": "The best answer is (" } + * ] + * ``` + * + * Then the response `content` might be: + * + * ```json + * [{ "type": "text", "text": "B)" }] + * ``` + */ + content: Array; + + /** + * The model that will complete your prompt.\n\nSee + * [models](https://docs.anthropic.com/en/docs/models-overview) for additional + * details and options. + */ + model: Model; + + /** + * Conversational role of the generated message. + * + * This will always be `"assistant"`. + */ + role: 'assistant'; + + /** + * The reason that we stopped. + * + * This may be one the following values: + * + * - `"end_turn"`: the model reached a natural stopping point + * - `"max_tokens"`: we exceeded the requested `max_tokens` or the model's maximum + * - `"stop_sequence"`: one of your provided custom `stop_sequences` was generated + * - `"tool_use"`: the model invoked one or more tools + * - `"pause_turn"`: we paused a long-running turn. You may provide the response + * back as-is in a subsequent request to let the model continue. + * - `"refusal"`: when streaming classifiers intervene to handle potential policy + * violations + * + * In non-streaming mode this value is always non-null. In streaming mode, it is + * null in the `message_start` event and non-null otherwise. + */ + stop_reason: StopReason | null; + + /** + * Which custom stop sequence was generated, if any. + * + * This value will be a non-null string if one of your custom stop sequences was + * generated. + */ + stop_sequence: string | null; + + /** + * Object type. + * + * For Messages, this is always `"message"`. + */ + type: 'message'; + + /** + * Billing and rate-limit usage. + * + * Anthropic's API bills and rate-limits by token counts, as tokens represent the + * underlying cost to our systems. + * + * Under the hood, the API transforms requests into a format suitable for the + * model. The model's output then goes through a parsing stage before becoming an + * API response. As a result, the token counts in `usage` will not match one-to-one + * with the exact visible content of an API request or response. + * + * For example, `output_tokens` will be non-zero, even for an empty string response + * from Claude. + * + * Total input tokens in a request is the summation of `input_tokens`, + * `cache_creation_input_tokens`, and `cache_read_input_tokens`. + */ + usage: Usage; +} + +export type MessageCountTokensTool = + | Tool + | ToolBash20250124 + | ToolTextEditor20250124 + | MessageCountTokensTool.TextEditor20250429 + | WebSearchTool20250305; + +export namespace MessageCountTokensTool { + export interface TextEditor20250429 { + /** + * Name of the tool. + * + * This is how the tool will be called by the model and in `tool_use` blocks. + */ + name: 'str_replace_based_edit_tool'; + + type: 'text_editor_20250429'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: MessagesAPI.CacheControlEphemeral | null; + } +} + +export interface MessageDeltaUsage { + /** + * The cumulative number of input tokens used to create the cache entry. + */ + cache_creation_input_tokens: number | null; + + /** + * The cumulative number of input tokens read from the cache. + */ + cache_read_input_tokens: number | null; + + /** + * The cumulative number of input tokens which were used. + */ + input_tokens: number | null; + + /** + * The cumulative number of output tokens which were used. + */ + output_tokens: number; + + /** + * The number of server tool requests. + */ + server_tool_use: ServerToolUsage | null; +} + +export interface MessageParam { + content: string | Array; + + role: 'user' | 'assistant'; +} + +export interface MessageTokensCount { + /** + * The total number of tokens across the provided list of messages, system prompt, + * and tools. + */ + input_tokens: number; +} + +export interface Metadata { + /** + * An external identifier for the user who is associated with the request. + * + * This should be a uuid, hash value, or other opaque identifier. Anthropic may use + * this id to help detect abuse. Do not include any identifying information such as + * name, email address, or phone number. + */ + user_id?: string | null; +} + +/** + * The model that will complete your prompt.\n\nSee + * [models](https://docs.anthropic.com/en/docs/models-overview) for additional + * details and options. + */ +export type Model = + | 'claude-3-7-sonnet-latest' + | 'claude-3-7-sonnet-20250219' + | 'claude-3-5-haiku-latest' + | 'claude-3-5-haiku-20241022' + | 'claude-sonnet-4-20250514' + | 'claude-sonnet-4-0' + | 'claude-4-sonnet-20250514' + | 'claude-3-5-sonnet-latest' + | 'claude-3-5-sonnet-20241022' + | 'claude-3-5-sonnet-20240620' + | 'claude-opus-4-0' + | 'claude-opus-4-20250514' + | 'claude-4-opus-20250514' + | 'claude-3-opus-latest' + | 'claude-3-opus-20240229' + | 'claude-3-sonnet-20240229' + | 'claude-3-haiku-20240307' + | 'claude-2.1' + | 'claude-2.0' + | (string & {}); + +const DEPRECATED_MODELS: { + [K in Model]?: string; +} = { + 'claude-1.3': 'November 6th, 2024', + 'claude-1.3-100k': 'November 6th, 2024', + 'claude-instant-1.1': 'November 6th, 2024', + 'claude-instant-1.1-100k': 'November 6th, 2024', + 'claude-instant-1.2': 'November 6th, 2024', + 'claude-3-sonnet-20240229': 'July 21st, 2025', + 'claude-3-opus-20240229': 'January 5th, 2026', + 'claude-2.1': 'July 21st, 2025', + 'claude-2.0': 'July 21st, 2025', +}; + +export interface PlainTextSource { + data: string; + + media_type: 'text/plain'; + + type: 'text'; +} + +export type RawContentBlockDelta = + | TextDelta + | InputJSONDelta + | CitationsDelta + | ThinkingDelta + | SignatureDelta; + +export interface RawContentBlockDeltaEvent { + delta: RawContentBlockDelta; + + index: number; + + type: 'content_block_delta'; +} + +export interface RawContentBlockStartEvent { + content_block: + | TextBlock + | ThinkingBlock + | RedactedThinkingBlock + | ToolUseBlock + | ServerToolUseBlock + | WebSearchToolResultBlock; + + index: number; + + type: 'content_block_start'; +} + +export interface RawContentBlockStopEvent { + index: number; + + type: 'content_block_stop'; +} + +export interface RawMessageDeltaEvent { + delta: RawMessageDeltaEvent.Delta; + + type: 'message_delta'; + + /** + * Billing and rate-limit usage. + * + * Anthropic's API bills and rate-limits by token counts, as tokens represent the + * underlying cost to our systems. + * + * Under the hood, the API transforms requests into a format suitable for the + * model. The model's output then goes through a parsing stage before becoming an + * API response. As a result, the token counts in `usage` will not match one-to-one + * with the exact visible content of an API request or response. + * + * For example, `output_tokens` will be non-zero, even for an empty string response + * from Claude. + * + * Total input tokens in a request is the summation of `input_tokens`, + * `cache_creation_input_tokens`, and `cache_read_input_tokens`. + */ + usage: MessageDeltaUsage; +} + +export namespace RawMessageDeltaEvent { + export interface Delta { + stop_reason: MessagesAPI.StopReason | null; + + stop_sequence: string | null; + } +} + +export interface RawMessageStartEvent { + message: Message; + + type: 'message_start'; +} + +export interface RawMessageStopEvent { + type: 'message_stop'; +} + +export type RawMessageStreamEvent = + | RawMessageStartEvent + | RawMessageDeltaEvent + | RawMessageStopEvent + | RawContentBlockStartEvent + | RawContentBlockDeltaEvent + | RawContentBlockStopEvent; + +export interface RedactedThinkingBlock { + data: string; + + type: 'redacted_thinking'; +} + +export interface RedactedThinkingBlockParam { + data: string; + + type: 'redacted_thinking'; +} + +export interface ServerToolUsage { + /** + * The number of web search tool requests. + */ + web_search_requests: number; +} + +export interface ServerToolUseBlock { + id: string; + + input: unknown; + + name: 'web_search'; + + type: 'server_tool_use'; +} + +export interface ServerToolUseBlockParam { + id: string; + + input: unknown; + + name: 'web_search'; + + type: 'server_tool_use'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: CacheControlEphemeral | null; +} + +export interface SignatureDelta { + signature: string; + + type: 'signature_delta'; +} + +export type StopReason = 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use' | 'pause_turn' | 'refusal'; + +export interface TextBlock { + /** + * Citations supporting the text block. + * + * The type of citation returned will depend on the type of document being cited. + * Citing a PDF results in `page_location`, plain text results in `char_location`, + * and content document results in `content_block_location`. + */ + citations: Array | null; + + text: string; + + type: 'text'; +} + +export interface TextBlockParam { + text: string; + + type: 'text'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: CacheControlEphemeral | null; + + citations?: Array | null; +} + +export type TextCitation = + | CitationCharLocation + | CitationPageLocation + | CitationContentBlockLocation + | CitationsWebSearchResultLocation; + +export type TextCitationParam = + | CitationCharLocationParam + | CitationPageLocationParam + | CitationContentBlockLocationParam + | CitationWebSearchResultLocationParam; + +export interface TextDelta { + text: string; + + type: 'text_delta'; +} + +export interface ThinkingBlock { + signature: string; + + thinking: string; + + type: 'thinking'; +} + +export interface ThinkingBlockParam { + signature: string; + + thinking: string; + + type: 'thinking'; +} + +export interface ThinkingConfigDisabled { + type: 'disabled'; +} + +export interface ThinkingConfigEnabled { + /** + * Determines how many tokens Claude can use for its internal reasoning process. + * Larger budgets can enable more thorough analysis for complex problems, improving + * response quality. + * + * Must be ≥1024 and less than `max_tokens`. + * + * See + * [extended thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking) + * for details. + */ + budget_tokens: number; + + type: 'enabled'; +} + +/** + * Configuration for enabling Claude's extended thinking. + * + * When enabled, responses include `thinking` content blocks showing Claude's + * thinking process before the final answer. Requires a minimum budget of 1,024 + * tokens and counts towards your `max_tokens` limit. + * + * See + * [extended thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking) + * for details. + */ +export type ThinkingConfigParam = ThinkingConfigEnabled | ThinkingConfigDisabled; + +export interface ThinkingDelta { + thinking: string; + + type: 'thinking_delta'; +} + +export interface Tool { + /** + * [JSON schema](https://json-schema.org/draft/2020-12) for this tool's input. + * + * This defines the shape of the `input` that your tool accepts and that the model + * will produce. + */ + input_schema: Tool.InputSchema; + + /** + * Name of the tool. + * + * This is how the tool will be called by the model and in `tool_use` blocks. + */ + name: string; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: CacheControlEphemeral | null; + + /** + * Description of what this tool does. + * + * Tool descriptions should be as detailed as possible. The more information that + * the model has about what the tool is and how to use it, the better it will + * perform. You can use natural language descriptions to reinforce important + * aspects of the tool input JSON schema. + */ + description?: string; + + type?: 'custom' | null; +} + +export namespace Tool { + /** + * [JSON schema](https://json-schema.org/draft/2020-12) for this tool's input. + * + * This defines the shape of the `input` that your tool accepts and that the model + * will produce. + */ + export interface InputSchema { + type: 'object'; + + properties?: unknown | null; + + required?: Array | null; + + [k: string]: unknown; + } +} + +export interface ToolBash20250124 { + /** + * Name of the tool. + * + * This is how the tool will be called by the model and in `tool_use` blocks. + */ + name: 'bash'; + + type: 'bash_20250124'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: CacheControlEphemeral | null; +} + +/** + * How the model should use the provided tools. The model can use a specific tool, + * any available tool, decide by itself, or not use tools at all. + */ +export type ToolChoice = ToolChoiceAuto | ToolChoiceAny | ToolChoiceTool | ToolChoiceNone; + +/** + * The model will use any available tools. + */ +export interface ToolChoiceAny { + type: 'any'; + + /** + * Whether to disable parallel tool use. + * + * Defaults to `false`. If set to `true`, the model will output exactly one tool + * use. + */ + disable_parallel_tool_use?: boolean; +} + +/** + * The model will automatically decide whether to use tools. + */ +export interface ToolChoiceAuto { + type: 'auto'; + + /** + * Whether to disable parallel tool use. + * + * Defaults to `false`. If set to `true`, the model will output at most one tool + * use. + */ + disable_parallel_tool_use?: boolean; +} + +/** + * The model will not be allowed to use tools. + */ +export interface ToolChoiceNone { + type: 'none'; +} + +/** + * The model will use the specified tool with `tool_choice.name`. + */ +export interface ToolChoiceTool { + /** + * The name of the tool to use. + */ + name: string; + + type: 'tool'; + + /** + * Whether to disable parallel tool use. + * + * Defaults to `false`. If set to `true`, the model will output exactly one tool + * use. + */ + disable_parallel_tool_use?: boolean; +} + +export interface ToolResultBlockParam { + tool_use_id: string; + + type: 'tool_result'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: CacheControlEphemeral | null; + + content?: string | Array; + + is_error?: boolean; +} + +export interface ToolTextEditor20250124 { + /** + * Name of the tool. + * + * This is how the tool will be called by the model and in `tool_use` blocks. + */ + name: 'str_replace_editor'; + + type: 'text_editor_20250124'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: CacheControlEphemeral | null; +} + +export type ToolUnion = + | Tool + | ToolBash20250124 + | ToolTextEditor20250124 + | ToolUnion.TextEditor20250429 + | WebSearchTool20250305; + +export namespace ToolUnion { + export interface TextEditor20250429 { + /** + * Name of the tool. + * + * This is how the tool will be called by the model and in `tool_use` blocks. + */ + name: 'str_replace_based_edit_tool'; + + type: 'text_editor_20250429'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: MessagesAPI.CacheControlEphemeral | null; + } +} + +export interface ToolUseBlock { + id: string; + + input: unknown; + + name: string; + + type: 'tool_use'; +} + +export interface ToolUseBlockParam { + id: string; + + input: unknown; + + name: string; + + type: 'tool_use'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: CacheControlEphemeral | null; +} + +export interface URLImageSource { + type: 'url'; + + url: string; +} + +export interface URLPDFSource { + type: 'url'; + + url: string; +} + +export interface Usage { + /** + * The number of input tokens used to create the cache entry. + */ + cache_creation_input_tokens: number | null; + + /** + * The number of input tokens read from the cache. + */ + cache_read_input_tokens: number | null; + + /** + * The number of input tokens which were used. + */ + input_tokens: number; + + /** + * The number of output tokens which were used. + */ + output_tokens: number; + + /** + * The number of server tool requests. + */ + server_tool_use: ServerToolUsage | null; + + /** + * If the request used the priority, standard, or batch tier. + */ + service_tier: 'standard' | 'priority' | 'batch' | null; +} + +export interface WebSearchResultBlock { + encrypted_content: string; + + page_age: string | null; + + title: string; + + type: 'web_search_result'; + + url: string; +} + +export interface WebSearchResultBlockParam { + encrypted_content: string; + + title: string; + + type: 'web_search_result'; + + url: string; + + page_age?: string | null; +} + +export interface WebSearchTool20250305 { + /** + * Name of the tool. + * + * This is how the tool will be called by the model and in `tool_use` blocks. + */ + name: 'web_search'; + + type: 'web_search_20250305'; + + /** + * If provided, only these domains will be included in results. Cannot be used + * alongside `blocked_domains`. + */ + allowed_domains?: Array | null; + + /** + * If provided, these domains will never appear in results. Cannot be used + * alongside `allowed_domains`. + */ + blocked_domains?: Array | null; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: CacheControlEphemeral | null; + + /** + * Maximum number of times the tool can be used in the API request. + */ + max_uses?: number | null; + + /** + * Parameters for the user's location. Used to provide more relevant search + * results. + */ + user_location?: WebSearchTool20250305.UserLocation | null; +} + +export namespace WebSearchTool20250305 { + /** + * Parameters for the user's location. Used to provide more relevant search + * results. + */ + export interface UserLocation { + type: 'approximate'; + + /** + * The city of the user. + */ + city?: string | null; + + /** + * The two letter + * [ISO country code](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) of the + * user. + */ + country?: string | null; + + /** + * The region of the user. + */ + region?: string | null; + + /** + * The [IANA timezone](https://nodatime.org/TimeZones) of the user. + */ + timezone?: string | null; + } +} + +export interface WebSearchToolRequestError { + error_code: + | 'invalid_tool_input' + | 'unavailable' + | 'max_uses_exceeded' + | 'too_many_requests' + | 'query_too_long'; + + type: 'web_search_tool_result_error'; +} + +export interface WebSearchToolResultBlock { + content: WebSearchToolResultBlockContent; + + tool_use_id: string; + + type: 'web_search_tool_result'; +} + +export type WebSearchToolResultBlockContent = WebSearchToolResultError | Array; + +export interface WebSearchToolResultBlockParam { + content: WebSearchToolResultBlockParamContent; + + tool_use_id: string; + + type: 'web_search_tool_result'; + + /** + * Create a cache control breakpoint at this content block. + */ + cache_control?: CacheControlEphemeral | null; +} + +export type WebSearchToolResultBlockParamContent = + | Array + | WebSearchToolRequestError; + +export interface WebSearchToolResultError { + error_code: + | 'invalid_tool_input' + | 'unavailable' + | 'max_uses_exceeded' + | 'too_many_requests' + | 'query_too_long'; + + type: 'web_search_tool_result_error'; +} + +export type MessageStreamEvent = RawMessageStreamEvent; + +export type MessageStartEvent = RawMessageStartEvent; + +export type MessageDeltaEvent = RawMessageDeltaEvent; + +export type MessageStopEvent = RawMessageStopEvent; + +export type ContentBlockStartEvent = RawContentBlockStartEvent; + +export type ContentBlockDeltaEvent = RawContentBlockDeltaEvent; + +export type ContentBlockStopEvent = RawContentBlockStopEvent; + +export type MessageCreateParams = MessageCreateParamsNonStreaming | MessageCreateParamsStreaming; + +export interface MessageCreateParamsBase { + /** + * The maximum number of tokens to generate before stopping. + * + * Note that our models may stop _before_ reaching this maximum. This parameter + * only specifies the absolute maximum number of tokens to generate. + * + * Different models have different maximum values for this parameter. See + * [models](https://docs.anthropic.com/en/docs/models-overview) for details. + */ + max_tokens: number; + + /** + * Input messages. + * + * Our models are trained to operate on alternating `user` and `assistant` + * conversational turns. When creating a new `Message`, you specify the prior + * conversational turns with the `messages` parameter, and the model then generates + * the next `Message` in the conversation. Consecutive `user` or `assistant` turns + * in your request will be combined into a single turn. + * + * Each input message must be an object with a `role` and `content`. You can + * specify a single `user`-role message, or you can include multiple `user` and + * `assistant` messages. + * + * If the final message uses the `assistant` role, the response content will + * continue immediately from the content in that message. This can be used to + * constrain part of the model's response. + * + * Example with a single `user` message: + * + * ```json + * [{ "role": "user", "content": "Hello, Claude" }] + * ``` + * + * Example with multiple conversational turns: + * + * ```json + * [ + * { "role": "user", "content": "Hello there." }, + * { "role": "assistant", "content": "Hi, I'm Claude. How can I help you?" }, + * { "role": "user", "content": "Can you explain LLMs in plain English?" } + * ] + * ``` + * + * Example with a partially-filled response from Claude: + * + * ```json + * [ + * { + * "role": "user", + * "content": "What's the Greek name for Sun? (A) Sol (B) Helios (C) Sun" + * }, + * { "role": "assistant", "content": "The best answer is (" } + * ] + * ``` + * + * Each input message `content` may be either a single `string` or an array of + * content blocks, where each block has a specific `type`. Using a `string` for + * `content` is shorthand for an array of one content block of type `"text"`. The + * following input messages are equivalent: + * + * ```json + * { "role": "user", "content": "Hello, Claude" } + * ``` + * + * ```json + * { "role": "user", "content": [{ "type": "text", "text": "Hello, Claude" }] } + * ``` + * + * Starting with Claude 3 models, you can also send image content blocks: + * + * ```json + * { + * "role": "user", + * "content": [ + * { + * "type": "image", + * "source": { + * "type": "base64", + * "media_type": "image/jpeg", + * "data": "/9j/4AAQSkZJRg..." + * } + * }, + * { "type": "text", "text": "What is in this image?" } + * ] + * } + * ``` + * + * We currently support the `base64` source type for images, and the `image/jpeg`, + * `image/png`, `image/gif`, and `image/webp` media types. + * + * See [examples](https://docs.anthropic.com/en/api/messages-examples#vision) for + * more input examples. + * + * Note that if you want to include a + * [system prompt](https://docs.anthropic.com/en/docs/system-prompts), you can use + * the top-level `system` parameter — there is no `"system"` role for input + * messages in the Messages API. + * + * There is a limit of 100,000 messages in a single request. + */ + messages: Array; + + /** + * The model that will complete your prompt.\n\nSee + * [models](https://docs.anthropic.com/en/docs/models-overview) for additional + * details and options. + */ + model: Model; + + /** + * An object describing metadata about the request. + */ + metadata?: Metadata; + + /** + * Determines whether to use priority capacity (if available) or standard capacity + * for this request. + * + * Anthropic offers different levels of service for your API requests. See + * [service-tiers](https://docs.anthropic.com/en/api/service-tiers) for details. + */ + service_tier?: 'auto' | 'standard_only'; + + /** + * Custom text sequences that will cause the model to stop generating. + * + * Our models will normally stop when they have naturally completed their turn, + * which will result in a response `stop_reason` of `"end_turn"`. + * + * If you want the model to stop generating when it encounters custom strings of + * text, you can use the `stop_sequences` parameter. If the model encounters one of + * the custom sequences, the response `stop_reason` value will be `"stop_sequence"` + * and the response `stop_sequence` value will contain the matched stop sequence. + */ + stop_sequences?: Array; + + /** + * Whether to incrementally stream the response using server-sent events. + * + * See [streaming](https://docs.anthropic.com/en/api/messages-streaming) for + * details. + */ + stream?: boolean; + + /** + * System prompt. + * + * A system prompt is a way of providing context and instructions to Claude, such + * as specifying a particular goal or role. See our + * [guide to system prompts](https://docs.anthropic.com/en/docs/system-prompts). + */ + system?: string | Array; + + /** + * Amount of randomness injected into the response. + * + * Defaults to `1.0`. Ranges from `0.0` to `1.0`. Use `temperature` closer to `0.0` + * for analytical / multiple choice, and closer to `1.0` for creative and + * generative tasks. + * + * Note that even with `temperature` of `0.0`, the results will not be fully + * deterministic. + */ + temperature?: number; + + /** + * Configuration for enabling Claude's extended thinking. + * + * When enabled, responses include `thinking` content blocks showing Claude's + * thinking process before the final answer. Requires a minimum budget of 1,024 + * tokens and counts towards your `max_tokens` limit. + * + * See + * [extended thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking) + * for details. + */ + thinking?: ThinkingConfigParam; + + /** + * How the model should use the provided tools. The model can use a specific tool, + * any available tool, decide by itself, or not use tools at all. + */ + tool_choice?: ToolChoice; + + /** + * Definitions of tools that the model may use. + * + * If you include `tools` in your API request, the model may return `tool_use` + * content blocks that represent the model's use of those tools. You can then run + * those tools using the tool input generated by the model and then optionally + * return results back to the model using `tool_result` content blocks. + * + * There are two types of tools: **client tools** and **server tools**. The + * behavior described below applies to client tools. For + * [server tools](https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/overview#server-tools), + * see their individual documentation as each has its own behavior (e.g., the + * [web search tool](https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/web-search-tool)). + * + * Each tool definition includes: + * + * - `name`: Name of the tool. + * - `description`: Optional, but strongly-recommended description of the tool. + * - `input_schema`: [JSON schema](https://json-schema.org/draft/2020-12) for the + * tool `input` shape that the model will produce in `tool_use` output content + * blocks. + * + * For example, if you defined `tools` as: + * + * ```json + * [ + * { + * "name": "get_stock_price", + * "description": "Get the current stock price for a given ticker symbol.", + * "input_schema": { + * "type": "object", + * "properties": { + * "ticker": { + * "type": "string", + * "description": "The stock ticker symbol, e.g. AAPL for Apple Inc." + * } + * }, + * "required": ["ticker"] + * } + * } + * ] + * ``` + * + * And then asked the model "What's the S&P 500 at today?", the model might produce + * `tool_use` content blocks in the response like this: + * + * ```json + * [ + * { + * "type": "tool_use", + * "id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV", + * "name": "get_stock_price", + * "input": { "ticker": "^GSPC" } + * } + * ] + * ``` + * + * You might then run your `get_stock_price` tool with `{"ticker": "^GSPC"}` as an + * input, and return the following back to the model in a subsequent `user` + * message: + * + * ```json + * [ + * { + * "type": "tool_result", + * "tool_use_id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV", + * "content": "259.75 USD" + * } + * ] + * ``` + * + * Tools can be used for workflows that include running client-side tools and + * functions, or more generally whenever you want the model to produce a particular + * JSON structure of output. + * + * See our [guide](https://docs.anthropic.com/en/docs/tool-use) for more details. + */ + tools?: Array; + + /** + * Only sample from the top K options for each subsequent token. + * + * Used to remove "long tail" low probability responses. + * [Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277). + * + * Recommended for advanced use cases only. You usually only need to use + * `temperature`. + */ + top_k?: number; + + /** + * Use nucleus sampling. + * + * In nucleus sampling, we compute the cumulative distribution over all the options + * for each subsequent token in decreasing probability order and cut it off once it + * reaches a particular probability specified by `top_p`. You should either alter + * `temperature` or `top_p`, but not both. + * + * Recommended for advanced use cases only. You usually only need to use + * `temperature`. + */ + top_p?: number; +} + +export namespace MessageCreateParams { + export type MessageCreateParamsNonStreaming = MessagesAPI.MessageCreateParamsNonStreaming; + export type MessageCreateParamsStreaming = MessagesAPI.MessageCreateParamsStreaming; +} + +export interface MessageCreateParamsNonStreaming extends MessageCreateParamsBase { + /** + * Whether to incrementally stream the response using server-sent events. + * + * See [streaming](https://docs.anthropic.com/en/api/messages-streaming) for + * details. + */ + stream?: false; +} + +export interface MessageCreateParamsStreaming extends MessageCreateParamsBase { + /** + * Whether to incrementally stream the response using server-sent events. + * + * See [streaming](https://docs.anthropic.com/en/api/messages-streaming) for + * details. + */ + stream: true; +} + +export type MessageStreamParams = MessageCreateParamsBase; + +export interface MessageCountTokensParams { + /** + * Input messages. + * + * Our models are trained to operate on alternating `user` and `assistant` + * conversational turns. When creating a new `Message`, you specify the prior + * conversational turns with the `messages` parameter, and the model then generates + * the next `Message` in the conversation. Consecutive `user` or `assistant` turns + * in your request will be combined into a single turn. + * + * Each input message must be an object with a `role` and `content`. You can + * specify a single `user`-role message, or you can include multiple `user` and + * `assistant` messages. + * + * If the final message uses the `assistant` role, the response content will + * continue immediately from the content in that message. This can be used to + * constrain part of the model's response. + * + * Example with a single `user` message: + * + * ```json + * [{ "role": "user", "content": "Hello, Claude" }] + * ``` + * + * Example with multiple conversational turns: + * + * ```json + * [ + * { "role": "user", "content": "Hello there." }, + * { "role": "assistant", "content": "Hi, I'm Claude. How can I help you?" }, + * { "role": "user", "content": "Can you explain LLMs in plain English?" } + * ] + * ``` + * + * Example with a partially-filled response from Claude: + * + * ```json + * [ + * { + * "role": "user", + * "content": "What's the Greek name for Sun? (A) Sol (B) Helios (C) Sun" + * }, + * { "role": "assistant", "content": "The best answer is (" } + * ] + * ``` + * + * Each input message `content` may be either a single `string` or an array of + * content blocks, where each block has a specific `type`. Using a `string` for + * `content` is shorthand for an array of one content block of type `"text"`. The + * following input messages are equivalent: + * + * ```json + * { "role": "user", "content": "Hello, Claude" } + * ``` + * + * ```json + * { "role": "user", "content": [{ "type": "text", "text": "Hello, Claude" }] } + * ``` + * + * Starting with Claude 3 models, you can also send image content blocks: + * + * ```json + * { + * "role": "user", + * "content": [ + * { + * "type": "image", + * "source": { + * "type": "base64", + * "media_type": "image/jpeg", + * "data": "/9j/4AAQSkZJRg..." + * } + * }, + * { "type": "text", "text": "What is in this image?" } + * ] + * } + * ``` + * + * We currently support the `base64` source type for images, and the `image/jpeg`, + * `image/png`, `image/gif`, and `image/webp` media types. + * + * See [examples](https://docs.anthropic.com/en/api/messages-examples#vision) for + * more input examples. + * + * Note that if you want to include a + * [system prompt](https://docs.anthropic.com/en/docs/system-prompts), you can use + * the top-level `system` parameter — there is no `"system"` role for input + * messages in the Messages API. + * + * There is a limit of 100,000 messages in a single request. + */ + messages: Array; + + /** + * The model that will complete your prompt.\n\nSee + * [models](https://docs.anthropic.com/en/docs/models-overview) for additional + * details and options. + */ + model: Model; + + /** + * System prompt. + * + * A system prompt is a way of providing context and instructions to Claude, such + * as specifying a particular goal or role. See our + * [guide to system prompts](https://docs.anthropic.com/en/docs/system-prompts). + */ + system?: string | Array; + + /** + * Configuration for enabling Claude's extended thinking. + * + * When enabled, responses include `thinking` content blocks showing Claude's + * thinking process before the final answer. Requires a minimum budget of 1,024 + * tokens and counts towards your `max_tokens` limit. + * + * See + * [extended thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking) + * for details. + */ + thinking?: ThinkingConfigParam; + + /** + * How the model should use the provided tools. The model can use a specific tool, + * any available tool, decide by itself, or not use tools at all. + */ + tool_choice?: ToolChoice; + + /** + * Definitions of tools that the model may use. + * + * If you include `tools` in your API request, the model may return `tool_use` + * content blocks that represent the model's use of those tools. You can then run + * those tools using the tool input generated by the model and then optionally + * return results back to the model using `tool_result` content blocks. + * + * There are two types of tools: **client tools** and **server tools**. The + * behavior described below applies to client tools. For + * [server tools](https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/overview#server-tools), + * see their individual documentation as each has its own behavior (e.g., the + * [web search tool](https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/web-search-tool)). + * + * Each tool definition includes: + * + * - `name`: Name of the tool. + * - `description`: Optional, but strongly-recommended description of the tool. + * - `input_schema`: [JSON schema](https://json-schema.org/draft/2020-12) for the + * tool `input` shape that the model will produce in `tool_use` output content + * blocks. + * + * For example, if you defined `tools` as: + * + * ```json + * [ + * { + * "name": "get_stock_price", + * "description": "Get the current stock price for a given ticker symbol.", + * "input_schema": { + * "type": "object", + * "properties": { + * "ticker": { + * "type": "string", + * "description": "The stock ticker symbol, e.g. AAPL for Apple Inc." + * } + * }, + * "required": ["ticker"] + * } + * } + * ] + * ``` + * + * And then asked the model "What's the S&P 500 at today?", the model might produce + * `tool_use` content blocks in the response like this: + * + * ```json + * [ + * { + * "type": "tool_use", + * "id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV", + * "name": "get_stock_price", + * "input": { "ticker": "^GSPC" } + * } + * ] + * ``` + * + * You might then run your `get_stock_price` tool with `{"ticker": "^GSPC"}` as an + * input, and return the following back to the model in a subsequent `user` + * message: + * + * ```json + * [ + * { + * "type": "tool_result", + * "tool_use_id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV", + * "content": "259.75 USD" + * } + * ] + * ``` + * + * Tools can be used for workflows that include running client-side tools and + * functions, or more generally whenever you want the model to produce a particular + * JSON structure of output. + * + * See our [guide](https://docs.anthropic.com/en/docs/tool-use) for more details. + */ + tools?: Array; +} + +Messages.Batches = Batches; + +export declare namespace Messages { + export { + type Base64ImageSource as Base64ImageSource, + type Base64PDFSource as Base64PDFSource, + type CacheControlEphemeral as CacheControlEphemeral, + type CitationCharLocation as CitationCharLocation, + type CitationCharLocationParam as CitationCharLocationParam, + type CitationContentBlockLocation as CitationContentBlockLocation, + type CitationContentBlockLocationParam as CitationContentBlockLocationParam, + type CitationPageLocation as CitationPageLocation, + type CitationPageLocationParam as CitationPageLocationParam, + type CitationWebSearchResultLocationParam as CitationWebSearchResultLocationParam, + type CitationsConfigParam as CitationsConfigParam, + type CitationsDelta as CitationsDelta, + type CitationsWebSearchResultLocation as CitationsWebSearchResultLocation, + type ContentBlock as ContentBlock, + type ContentBlockParam as ContentBlockParam, + type ContentBlockStartEvent as ContentBlockStartEvent, + type ContentBlockStopEvent as ContentBlockStopEvent, + type ContentBlockSource as ContentBlockSource, + type ContentBlockSourceContent as ContentBlockSourceContent, + type DocumentBlockParam as DocumentBlockParam, + type ImageBlockParam as ImageBlockParam, + type InputJSONDelta as InputJSONDelta, + type Message as Message, + type MessageCountTokensTool as MessageCountTokensTool, + type MessageDeltaEvent as MessageDeltaEvent, + type MessageDeltaUsage as MessageDeltaUsage, + type MessageParam as MessageParam, + type MessageTokensCount as MessageTokensCount, + type Metadata as Metadata, + type Model as Model, + type PlainTextSource as PlainTextSource, + type RawContentBlockDelta as RawContentBlockDelta, + type RawContentBlockDeltaEvent as RawContentBlockDeltaEvent, + type RawContentBlockStartEvent as RawContentBlockStartEvent, + type RawContentBlockStopEvent as RawContentBlockStopEvent, + type RawMessageDeltaEvent as RawMessageDeltaEvent, + type RawMessageStartEvent as RawMessageStartEvent, + type RawMessageStopEvent as RawMessageStopEvent, + type RawMessageStreamEvent as RawMessageStreamEvent, + type RedactedThinkingBlock as RedactedThinkingBlock, + type RedactedThinkingBlockParam as RedactedThinkingBlockParam, + type ServerToolUsage as ServerToolUsage, + type ServerToolUseBlock as ServerToolUseBlock, + type ServerToolUseBlockParam as ServerToolUseBlockParam, + type SignatureDelta as SignatureDelta, + type StopReason as StopReason, + type TextBlock as TextBlock, + type TextBlockParam as TextBlockParam, + type TextCitation as TextCitation, + type TextCitationParam as TextCitationParam, + type TextDelta as TextDelta, + type ThinkingBlock as ThinkingBlock, + type ThinkingBlockParam as ThinkingBlockParam, + type ThinkingConfigDisabled as ThinkingConfigDisabled, + type ThinkingConfigEnabled as ThinkingConfigEnabled, + type ThinkingConfigParam as ThinkingConfigParam, + type ThinkingDelta as ThinkingDelta, + type Tool as Tool, + type ToolBash20250124 as ToolBash20250124, + type ToolChoice as ToolChoice, + type ToolChoiceAny as ToolChoiceAny, + type ToolChoiceAuto as ToolChoiceAuto, + type ToolChoiceNone as ToolChoiceNone, + type ToolChoiceTool as ToolChoiceTool, + type ToolResultBlockParam as ToolResultBlockParam, + type ToolTextEditor20250124 as ToolTextEditor20250124, + type ToolUnion as ToolUnion, + type ToolUseBlock as ToolUseBlock, + type ToolUseBlockParam as ToolUseBlockParam, + type URLImageSource as URLImageSource, + type URLPDFSource as URLPDFSource, + type Usage as Usage, + type WebSearchResultBlock as WebSearchResultBlock, + type WebSearchResultBlockParam as WebSearchResultBlockParam, + type WebSearchTool20250305 as WebSearchTool20250305, + type WebSearchToolRequestError as WebSearchToolRequestError, + type WebSearchToolResultBlock as WebSearchToolResultBlock, + type WebSearchToolResultBlockContent as WebSearchToolResultBlockContent, + type WebSearchToolResultBlockParam as WebSearchToolResultBlockParam, + type WebSearchToolResultBlockParamContent as WebSearchToolResultBlockParamContent, + type WebSearchToolResultError as WebSearchToolResultError, + type MessageStreamEvent as MessageStreamEvent, + type MessageStartEvent as MessageStartEvent, + type MessageStopEvent as MessageStopEvent, + type ContentBlockDeltaEvent as ContentBlockDeltaEvent, + type MessageCreateParams as MessageCreateParams, + type MessageCreateParamsNonStreaming as MessageCreateParamsNonStreaming, + type MessageCreateParamsStreaming as MessageCreateParamsStreaming, + type MessageStreamParams as MessageStreamParams, + type MessageCountTokensParams as MessageCountTokensParams, + }; + + export { + Batches as Batches, + type DeletedMessageBatch as DeletedMessageBatch, + type MessageBatch as MessageBatch, + type MessageBatchCanceledResult as MessageBatchCanceledResult, + type MessageBatchErroredResult as MessageBatchErroredResult, + type MessageBatchExpiredResult as MessageBatchExpiredResult, + type MessageBatchIndividualResponse as MessageBatchIndividualResponse, + type MessageBatchRequestCounts as MessageBatchRequestCounts, + type MessageBatchResult as MessageBatchResult, + type MessageBatchSucceededResult as MessageBatchSucceededResult, + type MessageBatchesPage as MessageBatchesPage, + type BatchCreateParams as BatchCreateParams, + type BatchListParams as BatchListParams, + }; +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/models.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/models.ts new file mode 100644 index 0000000000000000000000000000000000000000..b42ae35519cf404fbddbd35733928f1744644e0e --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/models.ts @@ -0,0 +1,103 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +import { APIResource } from '../core/resource'; +import * as BetaAPI from './beta/beta'; +import { APIPromise } from '../core/api-promise'; +import { Page, type PageParams, PagePromise } from '../core/pagination'; +import { buildHeaders } from '../internal/headers'; +import { RequestOptions } from '../internal/request-options'; +import { path } from '../internal/utils/path'; + +export class Models extends APIResource { + /** + * Get a specific model. + * + * The Models API response can be used to determine information about a specific + * model or resolve a model alias to a model ID. + */ + retrieve( + modelID: string, + params: ModelRetrieveParams | null | undefined = {}, + options?: RequestOptions, + ): APIPromise { + const { betas } = params ?? {}; + return this._client.get(path`/v1/models/${modelID}`, { + ...options, + headers: buildHeaders([ + { ...(betas?.toString() != null ? { 'anthropic-beta': betas?.toString() } : undefined) }, + options?.headers, + ]), + }); + } + + /** + * List available models. + * + * The Models API response can be used to determine which models are available for + * use in the API. More recently released models are listed first. + */ + list( + params: ModelListParams | null | undefined = {}, + options?: RequestOptions, + ): PagePromise { + const { betas, ...query } = params ?? {}; + return this._client.getAPIList('/v1/models', Page, { + query, + ...options, + headers: buildHeaders([ + { ...(betas?.toString() != null ? { 'anthropic-beta': betas?.toString() } : undefined) }, + options?.headers, + ]), + }); + } +} + +export type ModelInfosPage = Page; + +export interface ModelInfo { + /** + * Unique model identifier. + */ + id: string; + + /** + * RFC 3339 datetime string representing the time at which the model was released. + * May be set to an epoch value if the release date is unknown. + */ + created_at: string; + + /** + * A human-readable name for the model. + */ + display_name: string; + + /** + * Object type. + * + * For Models, this is always `"model"`. + */ + type: 'model'; +} + +export interface ModelRetrieveParams { + /** + * Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export interface ModelListParams extends PageParams { + /** + * Header param: Optional header to specify the beta version(s) you want to use. + */ + betas?: Array; +} + +export declare namespace Models { + export { + type ModelInfo as ModelInfo, + type ModelInfosPage as ModelInfosPage, + type ModelRetrieveParams as ModelRetrieveParams, + type ModelListParams as ModelListParams, + }; +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/shared.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/shared.ts new file mode 100644 index 0000000000000000000000000000000000000000..d731c1f986644f7e74e706d441bb43493f2179ab --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/shared.ts @@ -0,0 +1,72 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +export interface APIErrorObject { + message: string; + + type: 'api_error'; +} + +export interface AuthenticationError { + message: string; + + type: 'authentication_error'; +} + +export interface BillingError { + message: string; + + type: 'billing_error'; +} + +export type ErrorObject = + | InvalidRequestError + | AuthenticationError + | BillingError + | PermissionError + | NotFoundError + | RateLimitError + | GatewayTimeoutError + | APIErrorObject + | OverloadedError; + +export interface ErrorResponse { + error: ErrorObject; + + type: 'error'; +} + +export interface GatewayTimeoutError { + message: string; + + type: 'timeout_error'; +} + +export interface InvalidRequestError { + message: string; + + type: 'invalid_request_error'; +} + +export interface NotFoundError { + message: string; + + type: 'not_found_error'; +} + +export interface OverloadedError { + message: string; + + type: 'overloaded_error'; +} + +export interface PermissionError { + message: string; + + type: 'permission_error'; +} + +export interface RateLimitError { + message: string; + + type: 'rate_limit_error'; +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/top-level.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/top-level.ts new file mode 100644 index 0000000000000000000000000000000000000000..b7426a62a507214266c84dc260a010b6002a406b --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/resources/top-level.ts @@ -0,0 +1,3 @@ +// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +export {}; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/streaming.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/streaming.ts new file mode 100644 index 0000000000000000000000000000000000000000..9e6da1063287d75edc54a69e4f6d03b5cd631667 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/streaming.ts @@ -0,0 +1,2 @@ +/** @deprecated Import from ./core/streaming instead */ +export * from './core/streaming'; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/tsconfig.json b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..c550e2996bc6f4af070fef8250f2a4ee8cdb5255 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/tsconfig.json @@ -0,0 +1,11 @@ +{ + // this config is included in the published src directory to prevent TS errors + // from appearing when users go to source, and VSCode opens the source .ts file + // via declaration maps + "include": ["index.ts"], + "compilerOptions": { + "target": "ES2015", + "lib": ["DOM", "DOM.Iterable", "ES2018"], + "moduleResolution": "node" + } +} diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/uploads.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/uploads.ts new file mode 100644 index 0000000000000000000000000000000000000000..b2ef64710fb618f1115aaee5650edd3aaa82ec45 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/uploads.ts @@ -0,0 +1,2 @@ +/** @deprecated Import from ./core/uploads instead */ +export * from './core/uploads'; diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/version.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/version.ts new file mode 100644 index 0000000000000000000000000000000000000000..63fdbe05927e5c0d5b0ac1d1ffdb2b2d77039dd6 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/src/version.ts @@ -0,0 +1 @@ +export const VERSION = '0.57.0'; // x-release-please-version diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.d.mts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f58cd7c64365327309fcc5ff63f56c50b1f1d7e9 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.d.mts @@ -0,0 +1,2 @@ +export * from "./core/streaming.mjs"; +//# sourceMappingURL=streaming.d.mts.map \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.d.mts.map b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..b1441091adec83c44c47c1d2abd3afa0d9d2744e --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"streaming.d.mts","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":""} \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.d.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..89ba506bff13498352a95d3f39683d6d472f664d --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.d.ts @@ -0,0 +1,2 @@ +export * from "./core/streaming.js"; +//# sourceMappingURL=streaming.d.ts.map \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.d.ts.map b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..5f9f18e89c5102c5fe5cd9b9ee3435c55104aba7 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":""} \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.js b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.js new file mode 100644 index 0000000000000000000000000000000000000000..ecb28fca3a03bf270c67b43a752a0cb8315f1f75 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.js @@ -0,0 +1,6 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const tslib_1 = require("./internal/tslib.js"); +/** @deprecated Import from ./core/streaming instead */ +tslib_1.__exportStar(require("./core/streaming.js"), exports); +//# sourceMappingURL=streaming.js.map \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.js.map b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.js.map new file mode 100644 index 0000000000000000000000000000000000000000..9cb042088370e7991b5b75b3a2f820c258f5d540 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.js.map @@ -0,0 +1 @@ +{"version":3,"file":"streaming.js","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":";;;AAAA,uDAAuD;AACvD,8DAAiC"} \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.mjs b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5ca840af4f06103b395b0fa35972306b466d5bb1 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.mjs @@ -0,0 +1,2 @@ +export * from "./core/streaming.mjs"; +//# sourceMappingURL=streaming.mjs.map \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.mjs.map b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.mjs.map new file mode 100644 index 0000000000000000000000000000000000000000..2e8344b070c75fcbaef39e08a8208b3556f26998 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/streaming.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"streaming.mjs","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":""} \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.d.mts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..997fb6f4a21760dadaab8f34900dcc9df2c0bf1b --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.d.mts @@ -0,0 +1,2 @@ +export * from "./core/uploads.mjs"; +//# sourceMappingURL=uploads.d.mts.map \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.d.mts.map b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..b3c3f2b1145a3ba150992543d6fcd42e13a14d9e --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"uploads.d.mts","sourceRoot":"","sources":["src/uploads.ts"],"names":[],"mappings":""} \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.d.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..27d0ae56175daf994d5a7c4db58e7a7bde4ecbe6 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.d.ts @@ -0,0 +1,2 @@ +export * from "./core/uploads.js"; +//# sourceMappingURL=uploads.d.ts.map \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.d.ts.map b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..7c12ec0e534dcdb8516f9193536ee0578b9b3d72 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"uploads.d.ts","sourceRoot":"","sources":["src/uploads.ts"],"names":[],"mappings":""} \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.js b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.js new file mode 100644 index 0000000000000000000000000000000000000000..5987729a9e467c3ac8c1d88274c7226e4b90029e --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.js @@ -0,0 +1,6 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const tslib_1 = require("./internal/tslib.js"); +/** @deprecated Import from ./core/uploads instead */ +tslib_1.__exportStar(require("./core/uploads.js"), exports); +//# sourceMappingURL=uploads.js.map \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.js.map b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.js.map new file mode 100644 index 0000000000000000000000000000000000000000..57711905ee8ca5105304f680d7e03eb28750a908 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.js.map @@ -0,0 +1 @@ +{"version":3,"file":"uploads.js","sourceRoot":"","sources":["src/uploads.ts"],"names":[],"mappings":";;;AAAA,qDAAqD;AACrD,4DAA+B"} \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.mjs b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.mjs new file mode 100644 index 0000000000000000000000000000000000000000..84fd6c421b74f8ac137fef3a9e1232f00f63069b --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.mjs @@ -0,0 +1,2 @@ +export * from "./core/uploads.mjs"; +//# sourceMappingURL=uploads.mjs.map \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.mjs.map b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.mjs.map new file mode 100644 index 0000000000000000000000000000000000000000..79d3c1a31d41d04fb56dc68ffade827991b7d3ae --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/uploads.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"uploads.mjs","sourceRoot":"","sources":["src/uploads.ts"],"names":[],"mappings":""} \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.d.mts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..74433ab3e5805dd571ca91fdedaf8646bc4adaad --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.d.mts @@ -0,0 +1,2 @@ +export declare const VERSION = "0.57.0"; +//# sourceMappingURL=version.d.mts.map \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.d.mts.map b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.d.mts.map new file mode 100644 index 0000000000000000000000000000000000000000..870679b98cf72e9f63bf0b84e1d8fbc227a2c6fa --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.d.mts.map @@ -0,0 +1 @@ +{"version":3,"file":"version.d.mts","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,WAAW,CAAC"} \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.d.ts b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5519d392207f2c9446ce9d24e8c5bb3780a520aa --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.d.ts @@ -0,0 +1,2 @@ +export declare const VERSION = "0.57.0"; +//# sourceMappingURL=version.d.ts.map \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.d.ts.map b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..e072bdd7a15c376e22ed360f66cda149fff769ac --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,WAAW,CAAC"} \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.js b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.js new file mode 100644 index 0000000000000000000000000000000000000000..07b2723a4f760ec6ee7218cd7d70ed3fa85f60ae --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.js @@ -0,0 +1,5 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.VERSION = void 0; +exports.VERSION = '0.57.0'; // x-release-please-version +//# sourceMappingURL=version.js.map \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.js.map b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.js.map new file mode 100644 index 0000000000000000000000000000000000000000..e9a6b4f01739d8724dad65ade9271280801ba000 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.js.map @@ -0,0 +1 @@ +{"version":3,"file":"version.js","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":";;;AAAa,QAAA,OAAO,GAAG,QAAQ,CAAC,CAAC,2BAA2B"} \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.mjs b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.mjs new file mode 100644 index 0000000000000000000000000000000000000000..42c3803daa8e1e337a7e7e84d019b5203205c267 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.mjs @@ -0,0 +1,2 @@ +export const VERSION = '0.57.0'; // x-release-please-version +//# sourceMappingURL=version.mjs.map \ No newline at end of file diff --git a/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.mjs.map b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.mjs.map new file mode 100644 index 0000000000000000000000000000000000000000..0c09c723b1318a6966eaf1482f5f556f052a5491 --- /dev/null +++ b/node_modules/.pnpm/@anthropic-ai+sdk@0.57.0/node_modules/@anthropic-ai/sdk/version.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"version.mjs","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,2BAA2B"} \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/LICENSE b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/README.md b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2f3368ef58e938d8016e762d4ca91aad338e6f50 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/README.md @@ -0,0 +1,19 @@ +# @babel/runtime + +> babel's modular runtime helpers + +See our website [@babel/runtime](https://babeljs.io/docs/babel-runtime) for more information. + +## Install + +Using npm: + +```sh +npm install --save @babel/runtime +``` + +or using yarn: + +```sh +yarn add @babel/runtime +``` diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/AwaitValue.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/AwaitValue.js new file mode 100644 index 0000000000000000000000000000000000000000..52a7e69a581f0161ff8f48b9b641bb33c263494b --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/AwaitValue.js @@ -0,0 +1,4 @@ +function _AwaitValue(t) { + this.wrapped = t; +} +module.exports = _AwaitValue, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/OverloadYield.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/OverloadYield.js new file mode 100644 index 0000000000000000000000000000000000000000..0eca88c7c000a4e8f1980ab38981e9994e5f32dc --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/OverloadYield.js @@ -0,0 +1,4 @@ +function _OverloadYield(e, d) { + this.v = e, this.k = d; +} +module.exports = _OverloadYield, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecoratedDescriptor.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecoratedDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..0ff780eba96e1e97ffa559e45c2acd1143e40903 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecoratedDescriptor.js @@ -0,0 +1,9 @@ +function _applyDecoratedDescriptor(i, e, r, n, l) { + var a = {}; + return Object.keys(n).forEach(function (i) { + a[i] = n[i]; + }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, ("value" in a || a.initializer) && (a.writable = !0), a = r.slice().reverse().reduce(function (r, n) { + return n(i, e, r) || r; + }, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a; +} +module.exports = _applyDecoratedDescriptor, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs.js new file mode 100644 index 0000000000000000000000000000000000000000..3770c5aee79a1e10aa5508fa4a4f5a223c334f94 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs.js @@ -0,0 +1,236 @@ +var _typeof = require("./typeof.js")["default"]; +var setFunctionName = require("./setFunctionName.js"); +var toPropertyKey = require("./toPropertyKey.js"); +function old_createMetadataMethodsForProperty(e, t, a, r) { + return { + getMetadata: function getMetadata(o) { + old_assertNotFinished(r, "getMetadata"), old_assertMetadataKey(o); + var i = e[o]; + if (void 0 !== i) if (1 === t) { + var n = i["public"]; + if (void 0 !== n) return n[a]; + } else if (2 === t) { + var l = i["private"]; + if (void 0 !== l) return l.get(a); + } else if (Object.hasOwnProperty.call(i, "constructor")) return i.constructor; + }, + setMetadata: function setMetadata(o, i) { + old_assertNotFinished(r, "setMetadata"), old_assertMetadataKey(o); + var n = e[o]; + if (void 0 === n && (n = e[o] = {}), 1 === t) { + var l = n["public"]; + void 0 === l && (l = n["public"] = {}), l[a] = i; + } else if (2 === t) { + var s = n.priv; + void 0 === s && (s = n["private"] = new Map()), s.set(a, i); + } else n.constructor = i; + } + }; +} +function old_convertMetadataMapToFinal(e, t) { + var a = e[Symbol.metadata || Symbol["for"]("Symbol.metadata")], + r = Object.getOwnPropertySymbols(t); + if (0 !== r.length) { + for (var o = 0; o < r.length; o++) { + var i = r[o], + n = t[i], + l = a ? a[i] : null, + s = n["public"], + c = l ? l["public"] : null; + s && c && Object.setPrototypeOf(s, c); + var d = n["private"]; + if (d) { + var u = Array.from(d.values()), + f = l ? l["private"] : null; + f && (u = u.concat(f)), n["private"] = u; + } + l && Object.setPrototypeOf(n, l); + } + a && Object.setPrototypeOf(t, a), e[Symbol.metadata || Symbol["for"]("Symbol.metadata")] = t; + } +} +function old_createAddInitializerMethod(e, t) { + return function (a) { + old_assertNotFinished(t, "addInitializer"), old_assertCallable(a, "An initializer"), e.push(a); + }; +} +function old_memberDec(e, t, a, r, o, i, n, l, s) { + var c; + switch (i) { + case 1: + c = "accessor"; + break; + case 2: + c = "method"; + break; + case 3: + c = "getter"; + break; + case 4: + c = "setter"; + break; + default: + c = "field"; + } + var d, + u, + f = { + kind: c, + name: l ? "#" + t : toPropertyKey(t), + isStatic: n, + isPrivate: l + }, + p = { + v: !1 + }; + if (0 !== i && (f.addInitializer = old_createAddInitializerMethod(o, p)), l) { + d = 2, u = Symbol(t); + var v = {}; + 0 === i ? (v.get = a.get, v.set = a.set) : 2 === i ? v.get = function () { + return a.value; + } : (1 !== i && 3 !== i || (v.get = function () { + return a.get.call(this); + }), 1 !== i && 4 !== i || (v.set = function (e) { + a.set.call(this, e); + })), f.access = v; + } else d = 1, u = t; + try { + return e(s, Object.assign(f, old_createMetadataMethodsForProperty(r, d, u, p))); + } finally { + p.v = !0; + } +} +function old_assertNotFinished(e, t) { + if (e.v) throw Error("attempted to call " + t + " after decoration was finished"); +} +function old_assertMetadataKey(e) { + if ("symbol" != _typeof(e)) throw new TypeError("Metadata keys must be symbols, received: " + e); +} +function old_assertCallable(e, t) { + if ("function" != typeof e) throw new TypeError(t + " must be a function"); +} +function old_assertValidReturnValue(e, t) { + var a = _typeof(t); + if (1 === e) { + if ("object" !== a || null === t) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); + void 0 !== t.get && old_assertCallable(t.get, "accessor.get"), void 0 !== t.set && old_assertCallable(t.set, "accessor.set"), void 0 !== t.init && old_assertCallable(t.init, "accessor.init"), void 0 !== t.initializer && old_assertCallable(t.initializer, "accessor.initializer"); + } else if ("function" !== a) throw new TypeError((0 === e ? "field" : 10 === e ? "class" : "method") + " decorators must return a function or void 0"); +} +function old_getInit(e) { + var t; + return null == (t = e.init) && (t = e.initializer) && void 0 !== console && console.warn(".initializer has been renamed to .init as of March 2022"), t; +} +function old_applyMemberDec(e, t, a, r, o, i, n, l, s) { + var c, + d, + u, + f, + p, + v, + y, + h = a[0]; + if (n ? (0 === o || 1 === o ? (c = { + get: a[3], + set: a[4] + }, u = "get") : 3 === o ? (c = { + get: a[3] + }, u = "get") : 4 === o ? (c = { + set: a[3] + }, u = "set") : c = { + value: a[3] + }, 0 !== o && (1 === o && setFunctionName(a[4], "#" + r, "set"), setFunctionName(a[3], "#" + r, u))) : 0 !== o && (c = Object.getOwnPropertyDescriptor(t, r)), 1 === o ? f = { + get: c.get, + set: c.set + } : 2 === o ? f = c.value : 3 === o ? f = c.get : 4 === o && (f = c.set), "function" == typeof h) void 0 !== (p = old_memberDec(h, r, c, l, s, o, i, n, f)) && (old_assertValidReturnValue(o, p), 0 === o ? d = p : 1 === o ? (d = old_getInit(p), v = p.get || f.get, y = p.set || f.set, f = { + get: v, + set: y + }) : f = p);else for (var m = h.length - 1; m >= 0; m--) { + var b; + void 0 !== (p = old_memberDec(h[m], r, c, l, s, o, i, n, f)) && (old_assertValidReturnValue(o, p), 0 === o ? b = p : 1 === o ? (b = old_getInit(p), v = p.get || f.get, y = p.set || f.set, f = { + get: v, + set: y + }) : f = p, void 0 !== b && (void 0 === d ? d = b : "function" == typeof d ? d = [d, b] : d.push(b))); + } + if (0 === o || 1 === o) { + if (void 0 === d) d = function d(e, t) { + return t; + };else if ("function" != typeof d) { + var g = d; + d = function d(e, t) { + for (var a = t, r = 0; r < g.length; r++) a = g[r].call(e, a); + return a; + }; + } else { + var _ = d; + d = function d(e, t) { + return _.call(e, t); + }; + } + e.push(d); + } + 0 !== o && (1 === o ? (c.get = f.get, c.set = f.set) : 2 === o ? c.value = f : 3 === o ? c.get = f : 4 === o && (c.set = f), n ? 1 === o ? (e.push(function (e, t) { + return f.get.call(e, t); + }), e.push(function (e, t) { + return f.set.call(e, t); + })) : 2 === o ? e.push(f) : e.push(function (e, t) { + return f.call(e, t); + }) : Object.defineProperty(t, r, c)); +} +function old_applyMemberDecs(e, t, a, r, o) { + for (var i, n, l = new Map(), s = new Map(), c = 0; c < o.length; c++) { + var d = o[c]; + if (Array.isArray(d)) { + var u, + f, + p, + v = d[1], + y = d[2], + h = d.length > 3, + m = v >= 5; + if (m ? (u = t, f = r, 0 != (v -= 5) && (p = n = n || [])) : (u = t.prototype, f = a, 0 !== v && (p = i = i || [])), 0 !== v && !h) { + var b = m ? s : l, + g = b.get(y) || 0; + if (!0 === g || 3 === g && 4 !== v || 4 === g && 3 !== v) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + y); + !g && v > 2 ? b.set(y, v) : b.set(y, !0); + } + old_applyMemberDec(e, u, d, y, v, m, h, f, p); + } + } + old_pushInitializers(e, i), old_pushInitializers(e, n); +} +function old_pushInitializers(e, t) { + t && e.push(function (e) { + for (var a = 0; a < t.length; a++) t[a].call(e); + return e; + }); +} +function old_applyClassDecs(e, t, a, r) { + if (r.length > 0) { + for (var o = [], i = t, n = t.name, l = r.length - 1; l >= 0; l--) { + var s = { + v: !1 + }; + try { + var c = Object.assign({ + kind: "class", + name: n, + addInitializer: old_createAddInitializerMethod(o, s) + }, old_createMetadataMethodsForProperty(a, 0, n, s)), + d = r[l](i, c); + } finally { + s.v = !0; + } + void 0 !== d && (old_assertValidReturnValue(10, d), i = d); + } + e.push(i, function () { + for (var e = 0; e < o.length; e++) o[e].call(i); + }); + } +} +function applyDecs(e, t, a) { + var r = [], + o = {}, + i = {}; + return old_applyMemberDecs(r, e, i, o, t), old_convertMetadataMapToFinal(e.prototype, i), old_applyClassDecs(r, e, o, a), old_convertMetadataMapToFinal(e, o), r; +} +module.exports = applyDecs, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs2203.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs2203.js new file mode 100644 index 0000000000000000000000000000000000000000..d3da333820443c674583a383382daddc40c043dd --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs2203.js @@ -0,0 +1,184 @@ +var _typeof = require("./typeof.js")["default"]; +function applyDecs2203Factory() { + function createAddInitializerMethod(e, t) { + return function (r) { + !function (e, t) { + if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); + }(t), assertCallable(r, "An initializer"), e.push(r); + }; + } + function memberDec(e, t, r, a, n, i, s, o) { + var c; + switch (n) { + case 1: + c = "accessor"; + break; + case 2: + c = "method"; + break; + case 3: + c = "getter"; + break; + case 4: + c = "setter"; + break; + default: + c = "field"; + } + var l, + u, + f = { + kind: c, + name: s ? "#" + t : t, + "static": i, + "private": s + }, + p = { + v: !1 + }; + 0 !== n && (f.addInitializer = createAddInitializerMethod(a, p)), 0 === n ? s ? (l = r.get, u = r.set) : (l = function l() { + return this[t]; + }, u = function u(e) { + this[t] = e; + }) : 2 === n ? l = function l() { + return r.value; + } : (1 !== n && 3 !== n || (l = function l() { + return r.get.call(this); + }), 1 !== n && 4 !== n || (u = function u(e) { + r.set.call(this, e); + })), f.access = l && u ? { + get: l, + set: u + } : l ? { + get: l + } : { + set: u + }; + try { + return e(o, f); + } finally { + p.v = !0; + } + } + function assertCallable(e, t) { + if ("function" != typeof e) throw new TypeError(t + " must be a function"); + } + function assertValidReturnValue(e, t) { + var r = _typeof(t); + if (1 === e) { + if ("object" !== r || null === t) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); + void 0 !== t.get && assertCallable(t.get, "accessor.get"), void 0 !== t.set && assertCallable(t.set, "accessor.set"), void 0 !== t.init && assertCallable(t.init, "accessor.init"); + } else if ("function" !== r) throw new TypeError((0 === e ? "field" : 10 === e ? "class" : "method") + " decorators must return a function or void 0"); + } + function applyMemberDec(e, t, r, a, n, i, s, o) { + var c, + l, + u, + f, + p, + d, + h = r[0]; + if (s ? c = 0 === n || 1 === n ? { + get: r[3], + set: r[4] + } : 3 === n ? { + get: r[3] + } : 4 === n ? { + set: r[3] + } : { + value: r[3] + } : 0 !== n && (c = Object.getOwnPropertyDescriptor(t, a)), 1 === n ? u = { + get: c.get, + set: c.set + } : 2 === n ? u = c.value : 3 === n ? u = c.get : 4 === n && (u = c.set), "function" == typeof h) void 0 !== (f = memberDec(h, a, c, o, n, i, s, u)) && (assertValidReturnValue(n, f), 0 === n ? l = f : 1 === n ? (l = f.init, p = f.get || u.get, d = f.set || u.set, u = { + get: p, + set: d + }) : u = f);else for (var v = h.length - 1; v >= 0; v--) { + var g; + void 0 !== (f = memberDec(h[v], a, c, o, n, i, s, u)) && (assertValidReturnValue(n, f), 0 === n ? g = f : 1 === n ? (g = f.init, p = f.get || u.get, d = f.set || u.set, u = { + get: p, + set: d + }) : u = f, void 0 !== g && (void 0 === l ? l = g : "function" == typeof l ? l = [l, g] : l.push(g))); + } + if (0 === n || 1 === n) { + if (void 0 === l) l = function l(e, t) { + return t; + };else if ("function" != typeof l) { + var y = l; + l = function l(e, t) { + for (var r = t, a = 0; a < y.length; a++) r = y[a].call(e, r); + return r; + }; + } else { + var m = l; + l = function l(e, t) { + return m.call(e, t); + }; + } + e.push(l); + } + 0 !== n && (1 === n ? (c.get = u.get, c.set = u.set) : 2 === n ? c.value = u : 3 === n ? c.get = u : 4 === n && (c.set = u), s ? 1 === n ? (e.push(function (e, t) { + return u.get.call(e, t); + }), e.push(function (e, t) { + return u.set.call(e, t); + })) : 2 === n ? e.push(u) : e.push(function (e, t) { + return u.call(e, t); + }) : Object.defineProperty(t, a, c)); + } + function pushInitializers(e, t) { + t && e.push(function (e) { + for (var r = 0; r < t.length; r++) t[r].call(e); + return e; + }); + } + return function (e, t, r) { + var a = []; + return function (e, t, r) { + for (var a, n, i = new Map(), s = new Map(), o = 0; o < r.length; o++) { + var c = r[o]; + if (Array.isArray(c)) { + var l, + u, + f = c[1], + p = c[2], + d = c.length > 3, + h = f >= 5; + if (h ? (l = t, 0 != (f -= 5) && (u = n = n || [])) : (l = t.prototype, 0 !== f && (u = a = a || [])), 0 !== f && !d) { + var v = h ? s : i, + g = v.get(p) || 0; + if (!0 === g || 3 === g && 4 !== f || 4 === g && 3 !== f) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + p); + !g && f > 2 ? v.set(p, f) : v.set(p, !0); + } + applyMemberDec(e, l, c, p, f, h, d, u); + } + } + pushInitializers(e, a), pushInitializers(e, n); + }(a, e, t), function (e, t, r) { + if (r.length > 0) { + for (var a = [], n = t, i = t.name, s = r.length - 1; s >= 0; s--) { + var o = { + v: !1 + }; + try { + var c = r[s](n, { + kind: "class", + name: i, + addInitializer: createAddInitializerMethod(a, o) + }); + } finally { + o.v = !0; + } + void 0 !== c && (assertValidReturnValue(10, c), n = c); + } + e.push(n, function () { + for (var e = 0; e < a.length; e++) a[e].call(n); + }); + } + }(a, e, r), a; + }; +} +var applyDecs2203Impl; +function applyDecs2203(e, t, r) { + return (applyDecs2203Impl = applyDecs2203Impl || applyDecs2203Factory())(e, t, r); +} +module.exports = applyDecs2203, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs2203R.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs2203R.js new file mode 100644 index 0000000000000000000000000000000000000000..725419b5b37c496f3ca27bfc9bb576ef03de4bc0 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs2203R.js @@ -0,0 +1,191 @@ +var _typeof = require("./typeof.js")["default"]; +var setFunctionName = require("./setFunctionName.js"); +var toPropertyKey = require("./toPropertyKey.js"); +function applyDecs2203RFactory() { + function createAddInitializerMethod(e, t) { + return function (r) { + !function (e, t) { + if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); + }(t), assertCallable(r, "An initializer"), e.push(r); + }; + } + function memberDec(e, t, r, n, a, i, o, s) { + var c; + switch (a) { + case 1: + c = "accessor"; + break; + case 2: + c = "method"; + break; + case 3: + c = "getter"; + break; + case 4: + c = "setter"; + break; + default: + c = "field"; + } + var l, + u, + f = { + kind: c, + name: o ? "#" + t : toPropertyKey(t), + "static": i, + "private": o + }, + p = { + v: !1 + }; + 0 !== a && (f.addInitializer = createAddInitializerMethod(n, p)), 0 === a ? o ? (l = r.get, u = r.set) : (l = function l() { + return this[t]; + }, u = function u(e) { + this[t] = e; + }) : 2 === a ? l = function l() { + return r.value; + } : (1 !== a && 3 !== a || (l = function l() { + return r.get.call(this); + }), 1 !== a && 4 !== a || (u = function u(e) { + r.set.call(this, e); + })), f.access = l && u ? { + get: l, + set: u + } : l ? { + get: l + } : { + set: u + }; + try { + return e(s, f); + } finally { + p.v = !0; + } + } + function assertCallable(e, t) { + if ("function" != typeof e) throw new TypeError(t + " must be a function"); + } + function assertValidReturnValue(e, t) { + var r = _typeof(t); + if (1 === e) { + if ("object" !== r || null === t) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); + void 0 !== t.get && assertCallable(t.get, "accessor.get"), void 0 !== t.set && assertCallable(t.set, "accessor.set"), void 0 !== t.init && assertCallable(t.init, "accessor.init"); + } else if ("function" !== r) throw new TypeError((0 === e ? "field" : 10 === e ? "class" : "method") + " decorators must return a function or void 0"); + } + function applyMemberDec(e, t, r, n, a, i, o, s) { + var c, + l, + u, + f, + p, + d, + h, + v = r[0]; + if (o ? (0 === a || 1 === a ? (c = { + get: r[3], + set: r[4] + }, u = "get") : 3 === a ? (c = { + get: r[3] + }, u = "get") : 4 === a ? (c = { + set: r[3] + }, u = "set") : c = { + value: r[3] + }, 0 !== a && (1 === a && setFunctionName(r[4], "#" + n, "set"), setFunctionName(r[3], "#" + n, u))) : 0 !== a && (c = Object.getOwnPropertyDescriptor(t, n)), 1 === a ? f = { + get: c.get, + set: c.set + } : 2 === a ? f = c.value : 3 === a ? f = c.get : 4 === a && (f = c.set), "function" == typeof v) void 0 !== (p = memberDec(v, n, c, s, a, i, o, f)) && (assertValidReturnValue(a, p), 0 === a ? l = p : 1 === a ? (l = p.init, d = p.get || f.get, h = p.set || f.set, f = { + get: d, + set: h + }) : f = p);else for (var g = v.length - 1; g >= 0; g--) { + var y; + void 0 !== (p = memberDec(v[g], n, c, s, a, i, o, f)) && (assertValidReturnValue(a, p), 0 === a ? y = p : 1 === a ? (y = p.init, d = p.get || f.get, h = p.set || f.set, f = { + get: d, + set: h + }) : f = p, void 0 !== y && (void 0 === l ? l = y : "function" == typeof l ? l = [l, y] : l.push(y))); + } + if (0 === a || 1 === a) { + if (void 0 === l) l = function l(e, t) { + return t; + };else if ("function" != typeof l) { + var m = l; + l = function l(e, t) { + for (var r = t, n = 0; n < m.length; n++) r = m[n].call(e, r); + return r; + }; + } else { + var b = l; + l = function l(e, t) { + return b.call(e, t); + }; + } + e.push(l); + } + 0 !== a && (1 === a ? (c.get = f.get, c.set = f.set) : 2 === a ? c.value = f : 3 === a ? c.get = f : 4 === a && (c.set = f), o ? 1 === a ? (e.push(function (e, t) { + return f.get.call(e, t); + }), e.push(function (e, t) { + return f.set.call(e, t); + })) : 2 === a ? e.push(f) : e.push(function (e, t) { + return f.call(e, t); + }) : Object.defineProperty(t, n, c)); + } + function applyMemberDecs(e, t) { + for (var r, n, a = [], i = new Map(), o = new Map(), s = 0; s < t.length; s++) { + var c = t[s]; + if (Array.isArray(c)) { + var l, + u, + f = c[1], + p = c[2], + d = c.length > 3, + h = f >= 5; + if (h ? (l = e, 0 != (f -= 5) && (u = n = n || [])) : (l = e.prototype, 0 !== f && (u = r = r || [])), 0 !== f && !d) { + var v = h ? o : i, + g = v.get(p) || 0; + if (!0 === g || 3 === g && 4 !== f || 4 === g && 3 !== f) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + p); + !g && f > 2 ? v.set(p, f) : v.set(p, !0); + } + applyMemberDec(a, l, c, p, f, h, d, u); + } + } + return pushInitializers(a, r), pushInitializers(a, n), a; + } + function pushInitializers(e, t) { + t && e.push(function (e) { + for (var r = 0; r < t.length; r++) t[r].call(e); + return e; + }); + } + return function (e, t, r) { + return { + e: applyMemberDecs(e, t), + get c() { + return function (e, t) { + if (t.length > 0) { + for (var r = [], n = e, a = e.name, i = t.length - 1; i >= 0; i--) { + var o = { + v: !1 + }; + try { + var s = t[i](n, { + kind: "class", + name: a, + addInitializer: createAddInitializerMethod(r, o) + }); + } finally { + o.v = !0; + } + void 0 !== s && (assertValidReturnValue(10, s), n = s); + } + return [n, function () { + for (var e = 0; e < r.length; e++) r[e].call(n); + }]; + } + }(e, r); + } + }; + }; +} +function applyDecs2203R(e, t, r) { + return (module.exports = applyDecs2203R = applyDecs2203RFactory(), module.exports.__esModule = true, module.exports["default"] = module.exports)(e, t, r); +} +module.exports = applyDecs2203R, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs2301.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs2301.js new file mode 100644 index 0000000000000000000000000000000000000000..fc2c130762614a917f53d1b3b3e7143ea3e2e9b2 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs2301.js @@ -0,0 +1,222 @@ +var _typeof = require("./typeof.js")["default"]; +var checkInRHS = require("./checkInRHS.js"); +var setFunctionName = require("./setFunctionName.js"); +var toPropertyKey = require("./toPropertyKey.js"); +function applyDecs2301Factory() { + function createAddInitializerMethod(e, t) { + return function (r) { + !function (e, t) { + if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); + }(t), assertCallable(r, "An initializer"), e.push(r); + }; + } + function assertInstanceIfPrivate(e, t) { + if (!e(t)) throw new TypeError("Attempted to access private element on non-instance"); + } + function memberDec(e, t, r, n, a, i, s, o, c) { + var u; + switch (a) { + case 1: + u = "accessor"; + break; + case 2: + u = "method"; + break; + case 3: + u = "getter"; + break; + case 4: + u = "setter"; + break; + default: + u = "field"; + } + var l, + f, + p = { + kind: u, + name: s ? "#" + t : toPropertyKey(t), + "static": i, + "private": s + }, + d = { + v: !1 + }; + if (0 !== a && (p.addInitializer = createAddInitializerMethod(n, d)), s || 0 !== a && 2 !== a) { + if (2 === a) l = function l(e) { + return assertInstanceIfPrivate(c, e), r.value; + };else { + var h = 0 === a || 1 === a; + (h || 3 === a) && (l = s ? function (e) { + return assertInstanceIfPrivate(c, e), r.get.call(e); + } : function (e) { + return r.get.call(e); + }), (h || 4 === a) && (f = s ? function (e, t) { + assertInstanceIfPrivate(c, e), r.set.call(e, t); + } : function (e, t) { + r.set.call(e, t); + }); + } + } else l = function l(e) { + return e[t]; + }, 0 === a && (f = function f(e, r) { + e[t] = r; + }); + var v = s ? c.bind() : function (e) { + return t in e; + }; + p.access = l && f ? { + get: l, + set: f, + has: v + } : l ? { + get: l, + has: v + } : { + set: f, + has: v + }; + try { + return e(o, p); + } finally { + d.v = !0; + } + } + function assertCallable(e, t) { + if ("function" != typeof e) throw new TypeError(t + " must be a function"); + } + function assertValidReturnValue(e, t) { + var r = _typeof(t); + if (1 === e) { + if ("object" !== r || null === t) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); + void 0 !== t.get && assertCallable(t.get, "accessor.get"), void 0 !== t.set && assertCallable(t.set, "accessor.set"), void 0 !== t.init && assertCallable(t.init, "accessor.init"); + } else if ("function" !== r) throw new TypeError((0 === e ? "field" : 10 === e ? "class" : "method") + " decorators must return a function or void 0"); + } + function curryThis2(e) { + return function (t) { + e(this, t); + }; + } + function applyMemberDec(e, t, r, n, a, i, s, o, c) { + var u, + l, + f, + p, + d, + h, + v, + y, + g = r[0]; + if (s ? (0 === a || 1 === a ? (u = { + get: (d = r[3], function () { + return d(this); + }), + set: curryThis2(r[4]) + }, f = "get") : 3 === a ? (u = { + get: r[3] + }, f = "get") : 4 === a ? (u = { + set: r[3] + }, f = "set") : u = { + value: r[3] + }, 0 !== a && (1 === a && setFunctionName(u.set, "#" + n, "set"), setFunctionName(u[f || "value"], "#" + n, f))) : 0 !== a && (u = Object.getOwnPropertyDescriptor(t, n)), 1 === a ? p = { + get: u.get, + set: u.set + } : 2 === a ? p = u.value : 3 === a ? p = u.get : 4 === a && (p = u.set), "function" == typeof g) void 0 !== (h = memberDec(g, n, u, o, a, i, s, p, c)) && (assertValidReturnValue(a, h), 0 === a ? l = h : 1 === a ? (l = h.init, v = h.get || p.get, y = h.set || p.set, p = { + get: v, + set: y + }) : p = h);else for (var m = g.length - 1; m >= 0; m--) { + var b; + void 0 !== (h = memberDec(g[m], n, u, o, a, i, s, p, c)) && (assertValidReturnValue(a, h), 0 === a ? b = h : 1 === a ? (b = h.init, v = h.get || p.get, y = h.set || p.set, p = { + get: v, + set: y + }) : p = h, void 0 !== b && (void 0 === l ? l = b : "function" == typeof l ? l = [l, b] : l.push(b))); + } + if (0 === a || 1 === a) { + if (void 0 === l) l = function l(e, t) { + return t; + };else if ("function" != typeof l) { + var I = l; + l = function l(e, t) { + for (var r = t, n = 0; n < I.length; n++) r = I[n].call(e, r); + return r; + }; + } else { + var w = l; + l = function l(e, t) { + return w.call(e, t); + }; + } + e.push(l); + } + 0 !== a && (1 === a ? (u.get = p.get, u.set = p.set) : 2 === a ? u.value = p : 3 === a ? u.get = p : 4 === a && (u.set = p), s ? 1 === a ? (e.push(function (e, t) { + return p.get.call(e, t); + }), e.push(function (e, t) { + return p.set.call(e, t); + })) : 2 === a ? e.push(p) : e.push(function (e, t) { + return p.call(e, t); + }) : Object.defineProperty(t, n, u)); + } + function applyMemberDecs(e, t, r) { + for (var n, a, i, s = [], o = new Map(), c = new Map(), u = 0; u < t.length; u++) { + var l = t[u]; + if (Array.isArray(l)) { + var f, + p, + d = l[1], + h = l[2], + v = l.length > 3, + y = d >= 5, + g = r; + if (y ? (f = e, 0 != (d -= 5) && (p = a = a || []), v && !i && (i = function i(t) { + return checkInRHS(t) === e; + }), g = i) : (f = e.prototype, 0 !== d && (p = n = n || [])), 0 !== d && !v) { + var m = y ? c : o, + b = m.get(h) || 0; + if (!0 === b || 3 === b && 4 !== d || 4 === b && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); + !b && d > 2 ? m.set(h, d) : m.set(h, !0); + } + applyMemberDec(s, f, l, h, d, y, v, p, g); + } + } + return pushInitializers(s, n), pushInitializers(s, a), s; + } + function pushInitializers(e, t) { + t && e.push(function (e) { + for (var r = 0; r < t.length; r++) t[r].call(e); + return e; + }); + } + return function (e, t, r, n) { + return { + e: applyMemberDecs(e, t, n), + get c() { + return function (e, t) { + if (t.length > 0) { + for (var r = [], n = e, a = e.name, i = t.length - 1; i >= 0; i--) { + var s = { + v: !1 + }; + try { + var o = t[i](n, { + kind: "class", + name: a, + addInitializer: createAddInitializerMethod(r, s) + }); + } finally { + s.v = !0; + } + void 0 !== o && (assertValidReturnValue(10, o), n = o); + } + return [n, function () { + for (var e = 0; e < r.length; e++) r[e].call(n); + }]; + } + }(e, r); + } + }; + }; +} +function applyDecs2301(e, t, r, n) { + return (module.exports = applyDecs2301 = applyDecs2301Factory(), module.exports.__esModule = true, module.exports["default"] = module.exports)(e, t, r, n); +} +module.exports = applyDecs2301, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs2305.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs2305.js new file mode 100644 index 0000000000000000000000000000000000000000..744c35212bdac019dcb8a8eb77efd394c25ac24b --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs2305.js @@ -0,0 +1,133 @@ +var _typeof = require("./typeof.js")["default"]; +var checkInRHS = require("./checkInRHS.js"); +var setFunctionName = require("./setFunctionName.js"); +var toPropertyKey = require("./toPropertyKey.js"); +function applyDecs2305(e, t, r, n, o, a) { + function i(e, t, r) { + return function (n, o) { + return r && r(n), e[t].call(n, o); + }; + } + function c(e, t) { + for (var r = 0; r < e.length; r++) e[r].call(t); + return t; + } + function s(e, t, r, n) { + if ("function" != typeof e && (n || void 0 !== e)) throw new TypeError(t + " must " + (r || "be") + " a function" + (n ? "" : " or undefined")); + return e; + } + function applyDec(e, t, r, n, o, a, c, u, l, f, p, d, h) { + function m(e) { + if (!h(e)) throw new TypeError("Attempted to access private element on non-instance"); + } + var y, + v = t[0], + g = t[3], + b = !u; + if (!b) { + r || Array.isArray(v) || (v = [v]); + var w = {}, + S = [], + A = 3 === o ? "get" : 4 === o || d ? "set" : "value"; + f ? (p || d ? w = { + get: setFunctionName(function () { + return g(this); + }, n, "get"), + set: function set(e) { + t[4](this, e); + } + } : w[A] = g, p || setFunctionName(w[A], n, 2 === o ? "" : A)) : p || (w = Object.getOwnPropertyDescriptor(e, n)); + } + for (var P = e, j = v.length - 1; j >= 0; j -= r ? 2 : 1) { + var D = v[j], + E = r ? v[j - 1] : void 0, + I = {}, + O = { + kind: ["field", "accessor", "method", "getter", "setter", "class"][o], + name: n, + metadata: a, + addInitializer: function (e, t) { + if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); + s(t, "An initializer", "be", !0), c.push(t); + }.bind(null, I) + }; + try { + if (b) (y = s(D.call(E, P, O), "class decorators", "return")) && (P = y);else { + var k, F; + O["static"] = l, O["private"] = f, f ? 2 === o ? k = function k(e) { + return m(e), w.value; + } : (o < 4 && (k = i(w, "get", m)), 3 !== o && (F = i(w, "set", m))) : (k = function k(e) { + return e[n]; + }, (o < 2 || 4 === o) && (F = function F(e, t) { + e[n] = t; + })); + var N = O.access = { + has: f ? h.bind() : function (e) { + return n in e; + } + }; + if (k && (N.get = k), F && (N.set = F), P = D.call(E, d ? { + get: w.get, + set: w.set + } : w[A], O), d) { + if ("object" == _typeof(P) && P) (y = s(P.get, "accessor.get")) && (w.get = y), (y = s(P.set, "accessor.set")) && (w.set = y), (y = s(P.init, "accessor.init")) && S.push(y);else if (void 0 !== P) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); + } else s(P, (p ? "field" : "method") + " decorators", "return") && (p ? S.push(P) : w[A] = P); + } + } finally { + I.v = !0; + } + } + return (p || d) && u.push(function (e, t) { + for (var r = S.length - 1; r >= 0; r--) t = S[r].call(e, t); + return t; + }), p || b || (f ? d ? u.push(i(w, "get"), i(w, "set")) : u.push(2 === o ? w[A] : i.call.bind(w[A])) : Object.defineProperty(e, n, w)), P; + } + function u(e, t) { + return Object.defineProperty(e, Symbol.metadata || Symbol["for"]("Symbol.metadata"), { + configurable: !0, + enumerable: !0, + value: t + }); + } + if (arguments.length >= 6) var l = a[Symbol.metadata || Symbol["for"]("Symbol.metadata")]; + var f = Object.create(null == l ? null : l), + p = function (e, t, r, n) { + var o, + a, + i = [], + s = function s(t) { + return checkInRHS(t) === e; + }, + u = new Map(); + function l(e) { + e && i.push(c.bind(null, e)); + } + for (var f = 0; f < t.length; f++) { + var p = t[f]; + if (Array.isArray(p)) { + var d = p[1], + h = p[2], + m = p.length > 3, + y = 16 & d, + v = !!(8 & d), + g = 0 == (d &= 7), + b = h + "/" + v; + if (!g && !m) { + var w = u.get(b); + if (!0 === w || 3 === w && 4 !== d || 4 === w && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); + u.set(b, !(d > 2) || d); + } + applyDec(v ? e : e.prototype, p, y, m ? "#" + h : toPropertyKey(h), d, n, v ? a = a || [] : o = o || [], i, v, m, g, 1 === d, v && m ? s : r); + } + } + return l(o), l(a), i; + }(e, t, o, f); + return r.length || u(e, f), { + e: p, + get c() { + var t = []; + return r.length && [u(applyDec(e, [r], n, e.name, 5, f, t), f), c.bind(null, t, e)]; + } + }; +} +module.exports = applyDecs2305, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs2311.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs2311.js new file mode 100644 index 0000000000000000000000000000000000000000..5f00a31135a48f096edb85f69f354945aabc20e7 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/applyDecs2311.js @@ -0,0 +1,124 @@ +var _typeof = require("./typeof.js")["default"]; +var checkInRHS = require("./checkInRHS.js"); +var setFunctionName = require("./setFunctionName.js"); +var toPropertyKey = require("./toPropertyKey.js"); +function applyDecs2311(e, t, n, r, o, i) { + var a, + c, + u, + s, + f, + l, + p, + d = Symbol.metadata || Symbol["for"]("Symbol.metadata"), + m = Object.defineProperty, + h = Object.create, + y = [h(null), h(null)], + v = t.length; + function g(t, n, r) { + return function (o, i) { + n && (i = o, o = e); + for (var a = 0; a < t.length; a++) i = t[a].apply(o, r ? [i] : []); + return r ? i : o; + }; + } + function b(e, t, n, r) { + if ("function" != typeof e && (r || void 0 !== e)) throw new TypeError(t + " must " + (n || "be") + " a function" + (r ? "" : " or undefined")); + return e; + } + function applyDec(e, t, n, r, o, i, u, s, f, l, p) { + function d(e) { + if (!p(e)) throw new TypeError("Attempted to access private element on non-instance"); + } + var h = [].concat(t[0]), + v = t[3], + w = !u, + D = 1 === o, + S = 3 === o, + j = 4 === o, + E = 2 === o; + function I(t, n, r) { + return function (o, i) { + return n && (i = o, o = e), r && r(o), P[t].call(o, i); + }; + } + if (!w) { + var P = {}, + k = [], + F = S ? "get" : j || D ? "set" : "value"; + if (f ? (l || D ? P = { + get: setFunctionName(function () { + return v(this); + }, r, "get"), + set: function set(e) { + t[4](this, e); + } + } : P[F] = v, l || setFunctionName(P[F], r, E ? "" : F)) : l || (P = Object.getOwnPropertyDescriptor(e, r)), !l && !f) { + if ((c = y[+s][r]) && 7 != (c ^ o)) throw Error("Decorating two elements with the same name (" + P[F].name + ") is not supported yet"); + y[+s][r] = o < 3 ? 1 : o; + } + } + for (var N = e, O = h.length - 1; O >= 0; O -= n ? 2 : 1) { + var T = b(h[O], "A decorator", "be", !0), + z = n ? h[O - 1] : void 0, + A = {}, + H = { + kind: ["field", "accessor", "method", "getter", "setter", "class"][o], + name: r, + metadata: a, + addInitializer: function (e, t) { + if (e.v) throw new TypeError("attempted to call addInitializer after decoration was finished"); + b(t, "An initializer", "be", !0), i.push(t); + }.bind(null, A) + }; + if (w) c = T.call(z, N, H), A.v = 1, b(c, "class decorators", "return") && (N = c);else if (H["static"] = s, H["private"] = f, c = H.access = { + has: f ? p.bind() : function (e) { + return r in e; + } + }, j || (c.get = f ? E ? function (e) { + return d(e), P.value; + } : I("get", 0, d) : function (e) { + return e[r]; + }), E || S || (c.set = f ? I("set", 0, d) : function (e, t) { + e[r] = t; + }), N = T.call(z, D ? { + get: P.get, + set: P.set + } : P[F], H), A.v = 1, D) { + if ("object" == _typeof(N) && N) (c = b(N.get, "accessor.get")) && (P.get = c), (c = b(N.set, "accessor.set")) && (P.set = c), (c = b(N.init, "accessor.init")) && k.unshift(c);else if (void 0 !== N) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined"); + } else b(N, (l ? "field" : "method") + " decorators", "return") && (l ? k.unshift(N) : P[F] = N); + } + return o < 2 && u.push(g(k, s, 1), g(i, s, 0)), l || w || (f ? D ? u.splice(-1, 0, I("get", s), I("set", s)) : u.push(E ? P[F] : b.call.bind(P[F])) : m(e, r, P)), N; + } + function w(e) { + return m(e, d, { + configurable: !0, + enumerable: !0, + value: a + }); + } + return void 0 !== i && (a = i[d]), a = h(null == a ? null : a), f = [], l = function l(e) { + e && f.push(g(e)); + }, p = function p(t, r) { + for (var i = 0; i < n.length; i++) { + var a = n[i], + c = a[1], + l = 7 & c; + if ((8 & c) == t && !l == r) { + var p = a[2], + d = !!a[3], + m = 16 & c; + applyDec(t ? e : e.prototype, a, m, d ? "#" + p : toPropertyKey(p), l, l < 2 ? [] : t ? s = s || [] : u = u || [], f, !!t, d, r, t && d ? function (t) { + return checkInRHS(t) === e; + } : o); + } + } + }, p(8, 0), p(0, 0), p(8, 1), p(0, 1), l(u), l(s), c = f, v || w(e), { + e: c, + get c() { + var n = []; + return v && [w(e = applyDec(e, [t], r, e.name, 5, n)), g(n, 1)]; + } + }; +} +module.exports = applyDecs2311, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/arrayLikeToArray.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/arrayLikeToArray.js new file mode 100644 index 0000000000000000000000000000000000000000..19787e31989579218c207db2bb34be54dc9a569a --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/arrayLikeToArray.js @@ -0,0 +1,6 @@ +function _arrayLikeToArray(r, a) { + (null == a || a > r.length) && (a = r.length); + for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; + return n; +} +module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/arrayWithHoles.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/arrayWithHoles.js new file mode 100644 index 0000000000000000000000000000000000000000..78bdd93199dd47e86aac3e3108b7092de3c5e8d0 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/arrayWithHoles.js @@ -0,0 +1,4 @@ +function _arrayWithHoles(r) { + if (Array.isArray(r)) return r; +} +module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js new file mode 100644 index 0000000000000000000000000000000000000000..42218f54a1791395952779760a161f1ed1372ed2 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/arrayWithoutHoles.js @@ -0,0 +1,5 @@ +var arrayLikeToArray = require("./arrayLikeToArray.js"); +function _arrayWithoutHoles(r) { + if (Array.isArray(r)) return arrayLikeToArray(r); +} +module.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/assertClassBrand.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/assertClassBrand.js new file mode 100644 index 0000000000000000000000000000000000000000..e63ed8f46f11d99e9b30404b862ae9bb30132eaa --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/assertClassBrand.js @@ -0,0 +1,5 @@ +function _assertClassBrand(e, t, n) { + if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; + throw new TypeError("Private element is not present on this object"); +} +module.exports = _assertClassBrand, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/assertThisInitialized.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/assertThisInitialized.js new file mode 100644 index 0000000000000000000000000000000000000000..02594fbe24b4b347d9b884001a16f6fe9cbae950 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/assertThisInitialized.js @@ -0,0 +1,5 @@ +function _assertThisInitialized(e) { + if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + return e; +} +module.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/asyncGeneratorDelegate.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/asyncGeneratorDelegate.js new file mode 100644 index 0000000000000000000000000000000000000000..023568e08ea0396305c7f7dfc3a36db6c2feafba --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/asyncGeneratorDelegate.js @@ -0,0 +1,24 @@ +var OverloadYield = require("./OverloadYield.js"); +function _asyncGeneratorDelegate(t) { + var e = {}, + n = !1; + function pump(e, r) { + return n = !0, r = new Promise(function (n) { + n(t[e](r)); + }), { + done: !1, + value: new OverloadYield(r, 1) + }; + } + return e["undefined" != typeof Symbol && Symbol.iterator || "@@iterator"] = function () { + return this; + }, e.next = function (t) { + return n ? (n = !1, t) : pump("next", t); + }, "function" == typeof t["throw"] && (e["throw"] = function (t) { + if (n) throw n = !1, t; + return pump("throw", t); + }), "function" == typeof t["return"] && (e["return"] = function (t) { + return n ? (n = !1, t) : pump("return", t); + }), e; +} +module.exports = _asyncGeneratorDelegate, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/asyncIterator.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/asyncIterator.js new file mode 100644 index 0000000000000000000000000000000000000000..9c0c95cfceddbffca7913b5ba3668824f7971801 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/asyncIterator.js @@ -0,0 +1,45 @@ +function _asyncIterator(r) { + var n, + t, + o, + e = 2; + for ("undefined" != typeof Symbol && (t = Symbol.asyncIterator, o = Symbol.iterator); e--;) { + if (t && null != (n = r[t])) return n.call(r); + if (o && null != (n = r[o])) return new AsyncFromSyncIterator(n.call(r)); + t = "@@asyncIterator", o = "@@iterator"; + } + throw new TypeError("Object is not async iterable"); +} +function AsyncFromSyncIterator(r) { + function AsyncFromSyncIteratorContinuation(r) { + if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object.")); + var n = r.done; + return Promise.resolve(r.value).then(function (r) { + return { + value: r, + done: n + }; + }); + } + return AsyncFromSyncIterator = function AsyncFromSyncIterator(r) { + this.s = r, this.n = r.next; + }, AsyncFromSyncIterator.prototype = { + s: null, + n: null, + next: function next() { + return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments)); + }, + "return": function _return(r) { + var n = this.s["return"]; + return void 0 === n ? Promise.resolve({ + value: r, + done: !0 + }) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments)); + }, + "throw": function _throw(r) { + var n = this.s["return"]; + return void 0 === n ? Promise.reject(r) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments)); + } + }, new AsyncFromSyncIterator(r); +} +module.exports = _asyncIterator, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/asyncToGenerator.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/asyncToGenerator.js new file mode 100644 index 0000000000000000000000000000000000000000..a080339bf98b7ec82fd8af00c817e00932aea33a --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/asyncToGenerator.js @@ -0,0 +1,26 @@ +function asyncGeneratorStep(n, t, e, r, o, a, c) { + try { + var i = n[a](c), + u = i.value; + } catch (n) { + return void e(n); + } + i.done ? t(u) : Promise.resolve(u).then(r, o); +} +function _asyncToGenerator(n) { + return function () { + var t = this, + e = arguments; + return new Promise(function (r, o) { + var a = n.apply(t, e); + function _next(n) { + asyncGeneratorStep(a, r, o, _next, _throw, "next", n); + } + function _throw(n) { + asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); + } + _next(void 0); + }); + }; +} +module.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/awaitAsyncGenerator.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/awaitAsyncGenerator.js new file mode 100644 index 0000000000000000000000000000000000000000..2d6fab916dbeaa399eda911d75bc162db9d1a360 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/awaitAsyncGenerator.js @@ -0,0 +1,5 @@ +var OverloadYield = require("./OverloadYield.js"); +function _awaitAsyncGenerator(e) { + return new OverloadYield(e, 0); +} +module.exports = _awaitAsyncGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/callSuper.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/callSuper.js new file mode 100644 index 0000000000000000000000000000000000000000..38eaf7f8b3768cae70fdd7ec40ddb2fcff30de40 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/callSuper.js @@ -0,0 +1,7 @@ +var getPrototypeOf = require("./getPrototypeOf.js"); +var isNativeReflectConstruct = require("./isNativeReflectConstruct.js"); +var possibleConstructorReturn = require("./possibleConstructorReturn.js"); +function _callSuper(t, o, e) { + return o = getPrototypeOf(o), possibleConstructorReturn(t, isNativeReflectConstruct() ? Reflect.construct(o, e || [], getPrototypeOf(t).constructor) : o.apply(t, e)); +} +module.exports = _callSuper, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/checkInRHS.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/checkInRHS.js new file mode 100644 index 0000000000000000000000000000000000000000..4eea13d923774977341cbe13f2b4d7e154a90bf4 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/checkInRHS.js @@ -0,0 +1,6 @@ +var _typeof = require("./typeof.js")["default"]; +function _checkInRHS(e) { + if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? _typeof(e) : "null")); + return e; +} +module.exports = _checkInRHS, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/checkPrivateRedeclaration.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/checkPrivateRedeclaration.js new file mode 100644 index 0000000000000000000000000000000000000000..33ad54c960c273e21e000e8c21e01e92aa8bb6e7 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/checkPrivateRedeclaration.js @@ -0,0 +1,4 @@ +function _checkPrivateRedeclaration(e, t) { + if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); +} +module.exports = _checkPrivateRedeclaration, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classApplyDescriptorDestructureSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classApplyDescriptorDestructureSet.js new file mode 100644 index 0000000000000000000000000000000000000000..9998b835525527098aeebe30b5a7b113a5e00f43 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classApplyDescriptorDestructureSet.js @@ -0,0 +1,10 @@ +function _classApplyDescriptorDestructureSet(e, t) { + if (t.set) return "__destrObj" in t || (t.__destrObj = { + set value(r) { + t.set.call(e, r); + } + }), t.__destrObj; + if (!t.writable) throw new TypeError("attempted to set read only private field"); + return t; +} +module.exports = _classApplyDescriptorDestructureSet, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classApplyDescriptorGet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classApplyDescriptorGet.js new file mode 100644 index 0000000000000000000000000000000000000000..ab627245499996f16b06376fc6d4ab50a2e68894 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classApplyDescriptorGet.js @@ -0,0 +1,4 @@ +function _classApplyDescriptorGet(e, t) { + return t.get ? t.get.call(e) : t.value; +} +module.exports = _classApplyDescriptorGet, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classApplyDescriptorSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classApplyDescriptorSet.js new file mode 100644 index 0000000000000000000000000000000000000000..0975f95fb56a00d43585563635b6310abd816d7f --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classApplyDescriptorSet.js @@ -0,0 +1,7 @@ +function _classApplyDescriptorSet(e, t, l) { + if (t.set) t.set.call(e, l);else { + if (!t.writable) throw new TypeError("attempted to set read only private field"); + t.value = l; + } +} +module.exports = _classApplyDescriptorSet, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classCallCheck.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classCallCheck.js new file mode 100644 index 0000000000000000000000000000000000000000..21b8390ff2fcd712eea49955e1f7fadbf965a9a2 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classCallCheck.js @@ -0,0 +1,4 @@ +function _classCallCheck(a, n) { + if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); +} +module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classCheckPrivateStaticAccess.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classCheckPrivateStaticAccess.js new file mode 100644 index 0000000000000000000000000000000000000000..7520f74dc777947531d74d9a44fdae5780c5c25d --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classCheckPrivateStaticAccess.js @@ -0,0 +1,5 @@ +var assertClassBrand = require("./assertClassBrand.js"); +function _classCheckPrivateStaticAccess(s, a, r) { + return assertClassBrand(a, s, r); +} +module.exports = _classCheckPrivateStaticAccess, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classCheckPrivateStaticFieldDescriptor.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classCheckPrivateStaticFieldDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..7f70395ea7618a52e1742dd1ac5b9be2db770286 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classCheckPrivateStaticFieldDescriptor.js @@ -0,0 +1,4 @@ +function _classCheckPrivateStaticFieldDescriptor(t, e) { + if (void 0 === t) throw new TypeError("attempted to " + e + " private static field before its declaration"); +} +module.exports = _classCheckPrivateStaticFieldDescriptor, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classExtractFieldDescriptor.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classExtractFieldDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..be855be9871309238097d6324e3e18ae47e75fa3 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classExtractFieldDescriptor.js @@ -0,0 +1,5 @@ +var classPrivateFieldGet2 = require("./classPrivateFieldGet2.js"); +function _classExtractFieldDescriptor(e, t) { + return classPrivateFieldGet2(t, e); +} +module.exports = _classExtractFieldDescriptor, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classNameTDZError.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classNameTDZError.js new file mode 100644 index 0000000000000000000000000000000000000000..8141ff89c0bb9c8a4a7be890f544f7352b8a2ced --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classNameTDZError.js @@ -0,0 +1,4 @@ +function _classNameTDZError(e) { + throw new ReferenceError('Class "' + e + '" cannot be referenced in computed property keys.'); +} +module.exports = _classNameTDZError, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldDestructureSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldDestructureSet.js new file mode 100644 index 0000000000000000000000000000000000000000..97c764d00c49370ffa0c5b3c8af77663aa604e48 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldDestructureSet.js @@ -0,0 +1,7 @@ +var classApplyDescriptorDestructureSet = require("./classApplyDescriptorDestructureSet.js"); +var classPrivateFieldGet2 = require("./classPrivateFieldGet2.js"); +function _classPrivateFieldDestructureSet(e, t) { + var r = classPrivateFieldGet2(t, e); + return classApplyDescriptorDestructureSet(e, r); +} +module.exports = _classPrivateFieldDestructureSet, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldGet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldGet.js new file mode 100644 index 0000000000000000000000000000000000000000..bbee142a375263ae867a39d3e1e1d1f12d6cce61 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldGet.js @@ -0,0 +1,7 @@ +var classApplyDescriptorGet = require("./classApplyDescriptorGet.js"); +var classPrivateFieldGet2 = require("./classPrivateFieldGet2.js"); +function _classPrivateFieldGet(e, t) { + var r = classPrivateFieldGet2(t, e); + return classApplyDescriptorGet(e, r); +} +module.exports = _classPrivateFieldGet, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldGet2.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldGet2.js new file mode 100644 index 0000000000000000000000000000000000000000..d4c271c71a7b058af142c62cb958b55eb3558b8f --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldGet2.js @@ -0,0 +1,5 @@ +var assertClassBrand = require("./assertClassBrand.js"); +function _classPrivateFieldGet2(s, a) { + return s.get(assertClassBrand(s, a)); +} +module.exports = _classPrivateFieldGet2, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldInitSpec.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldInitSpec.js new file mode 100644 index 0000000000000000000000000000000000000000..a290c19a21b8e3505077dad4c1a87964d53edacb --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldInitSpec.js @@ -0,0 +1,5 @@ +var checkPrivateRedeclaration = require("./checkPrivateRedeclaration.js"); +function _classPrivateFieldInitSpec(e, t, a) { + checkPrivateRedeclaration(e, t), t.set(e, a); +} +module.exports = _classPrivateFieldInitSpec, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldLooseBase.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldLooseBase.js new file mode 100644 index 0000000000000000000000000000000000000000..f9e46f267a38fb4e19044c54bcbed5493c63e4c4 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldLooseBase.js @@ -0,0 +1,5 @@ +function _classPrivateFieldBase(e, t) { + if (!{}.hasOwnProperty.call(e, t)) throw new TypeError("attempted to use private field on non-instance"); + return e; +} +module.exports = _classPrivateFieldBase, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldLooseKey.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldLooseKey.js new file mode 100644 index 0000000000000000000000000000000000000000..5dc687fe77ad1a77b6dc747cda37260319c22f02 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldLooseKey.js @@ -0,0 +1,5 @@ +var id = 0; +function _classPrivateFieldKey(e) { + return "__private_" + id++ + "_" + e; +} +module.exports = _classPrivateFieldKey, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldSet.js new file mode 100644 index 0000000000000000000000000000000000000000..f3746e74292bb2a935dab5f120e6be9677ef9e4a --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldSet.js @@ -0,0 +1,7 @@ +var classApplyDescriptorSet = require("./classApplyDescriptorSet.js"); +var classPrivateFieldGet2 = require("./classPrivateFieldGet2.js"); +function _classPrivateFieldSet(e, t, r) { + var s = classPrivateFieldGet2(t, e); + return classApplyDescriptorSet(e, s, r), r; +} +module.exports = _classPrivateFieldSet, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldSet2.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldSet2.js new file mode 100644 index 0000000000000000000000000000000000000000..25c60caaa4c5c866fb3e85427ed5439135ce1e1e --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateFieldSet2.js @@ -0,0 +1,5 @@ +var assertClassBrand = require("./assertClassBrand.js"); +function _classPrivateFieldSet2(s, a, r) { + return s.set(assertClassBrand(s, a), r), r; +} +module.exports = _classPrivateFieldSet2, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateGetter.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateGetter.js new file mode 100644 index 0000000000000000000000000000000000000000..1b3cf30a5005fea607c6cc85bd3dff587d7c943f --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateGetter.js @@ -0,0 +1,5 @@ +var assertClassBrand = require("./assertClassBrand.js"); +function _classPrivateGetter(s, r, a) { + return a(assertClassBrand(s, r)); +} +module.exports = _classPrivateGetter, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateMethodGet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateMethodGet.js new file mode 100644 index 0000000000000000000000000000000000000000..e4af38785b5186d8292a5db52e093d459afc929f --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateMethodGet.js @@ -0,0 +1,5 @@ +var assertClassBrand = require("./assertClassBrand.js"); +function _classPrivateMethodGet(s, a, r) { + return assertClassBrand(a, s), r; +} +module.exports = _classPrivateMethodGet, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateMethodInitSpec.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateMethodInitSpec.js new file mode 100644 index 0000000000000000000000000000000000000000..821c8ed00c757b0a53efee18e337eb37b1bd8eaa --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateMethodInitSpec.js @@ -0,0 +1,5 @@ +var checkPrivateRedeclaration = require("./checkPrivateRedeclaration.js"); +function _classPrivateMethodInitSpec(e, a) { + checkPrivateRedeclaration(e, a), a.add(e); +} +module.exports = _classPrivateMethodInitSpec, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateMethodSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateMethodSet.js new file mode 100644 index 0000000000000000000000000000000000000000..a44fd785361f883482634803b03124a84d1e950c --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateMethodSet.js @@ -0,0 +1,4 @@ +function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); +} +module.exports = _classPrivateMethodSet, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateSetter.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateSetter.js new file mode 100644 index 0000000000000000000000000000000000000000..494f81f0e5c3d0038c084bec68e0ebdc50983b42 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classPrivateSetter.js @@ -0,0 +1,5 @@ +var assertClassBrand = require("./assertClassBrand.js"); +function _classPrivateSetter(s, r, a, t) { + return r(assertClassBrand(s, a), t), t; +} +module.exports = _classPrivateSetter, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classStaticPrivateFieldDestructureSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classStaticPrivateFieldDestructureSet.js new file mode 100644 index 0000000000000000000000000000000000000000..2bb6e8b1c96fc26936c95734d5adccc9f785d46c --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classStaticPrivateFieldDestructureSet.js @@ -0,0 +1,7 @@ +var classApplyDescriptorDestructureSet = require("./classApplyDescriptorDestructureSet.js"); +var assertClassBrand = require("./assertClassBrand.js"); +var classCheckPrivateStaticFieldDescriptor = require("./classCheckPrivateStaticFieldDescriptor.js"); +function _classStaticPrivateFieldDestructureSet(t, r, s) { + return assertClassBrand(r, t), classCheckPrivateStaticFieldDescriptor(s, "set"), classApplyDescriptorDestructureSet(t, s); +} +module.exports = _classStaticPrivateFieldDestructureSet, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecGet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecGet.js new file mode 100644 index 0000000000000000000000000000000000000000..eb2365f3d8af2b881d69c21c013645c57fcd3102 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecGet.js @@ -0,0 +1,7 @@ +var classApplyDescriptorGet = require("./classApplyDescriptorGet.js"); +var assertClassBrand = require("./assertClassBrand.js"); +var classCheckPrivateStaticFieldDescriptor = require("./classCheckPrivateStaticFieldDescriptor.js"); +function _classStaticPrivateFieldSpecGet(t, s, r) { + return assertClassBrand(s, t), classCheckPrivateStaticFieldDescriptor(r, "get"), classApplyDescriptorGet(t, r); +} +module.exports = _classStaticPrivateFieldSpecGet, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecSet.js new file mode 100644 index 0000000000000000000000000000000000000000..7783cd8dd0976981ccbacbdbe6f226c85abe9279 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classStaticPrivateFieldSpecSet.js @@ -0,0 +1,7 @@ +var classApplyDescriptorSet = require("./classApplyDescriptorSet.js"); +var assertClassBrand = require("./assertClassBrand.js"); +var classCheckPrivateStaticFieldDescriptor = require("./classCheckPrivateStaticFieldDescriptor.js"); +function _classStaticPrivateFieldSpecSet(s, t, r, e) { + return assertClassBrand(t, s), classCheckPrivateStaticFieldDescriptor(r, "set"), classApplyDescriptorSet(s, r, e), e; +} +module.exports = _classStaticPrivateFieldSpecSet, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classStaticPrivateMethodGet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classStaticPrivateMethodGet.js new file mode 100644 index 0000000000000000000000000000000000000000..c895be5c609483e32f25cecf41767e93812487ad --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classStaticPrivateMethodGet.js @@ -0,0 +1,5 @@ +var assertClassBrand = require("./assertClassBrand.js"); +function _classStaticPrivateMethodGet(s, a, t) { + return assertClassBrand(a, s), t; +} +module.exports = _classStaticPrivateMethodGet, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classStaticPrivateMethodSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classStaticPrivateMethodSet.js new file mode 100644 index 0000000000000000000000000000000000000000..72560e6607e030d921a5ce8aa9896afd07dfd9be --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/classStaticPrivateMethodSet.js @@ -0,0 +1,4 @@ +function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); +} +module.exports = _classStaticPrivateMethodSet, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/construct.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/construct.js new file mode 100644 index 0000000000000000000000000000000000000000..aee8e70448824f509d6605e2dfa4455167442f21 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/construct.js @@ -0,0 +1,10 @@ +var isNativeReflectConstruct = require("./isNativeReflectConstruct.js"); +var setPrototypeOf = require("./setPrototypeOf.js"); +function _construct(t, e, r) { + if (isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments); + var o = [null]; + o.push.apply(o, e); + var p = new (t.bind.apply(t, o))(); + return r && setPrototypeOf(p, r.prototype), p; +} +module.exports = _construct, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/createClass.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/createClass.js new file mode 100644 index 0000000000000000000000000000000000000000..8757f9ee8f433d75d6aeee62874f693144ec1bfa --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/createClass.js @@ -0,0 +1,13 @@ +var toPropertyKey = require("./toPropertyKey.js"); +function _defineProperties(e, r) { + for (var t = 0; t < r.length; t++) { + var o = r[t]; + o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, toPropertyKey(o.key), o); + } +} +function _createClass(e, r, t) { + return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { + writable: !1 + }), e; +} +module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js new file mode 100644 index 0000000000000000000000000000000000000000..277830792a6d3af9832e1f4e9a0ac98d1f81c868 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js @@ -0,0 +1,50 @@ +var unsupportedIterableToArray = require("./unsupportedIterableToArray.js"); +function _createForOfIteratorHelper(r, e) { + var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; + if (!t) { + if (Array.isArray(r) || (t = unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { + t && (r = t); + var _n = 0, + F = function F() {}; + return { + s: F, + n: function n() { + return _n >= r.length ? { + done: !0 + } : { + done: !1, + value: r[_n++] + }; + }, + e: function e(r) { + throw r; + }, + f: F + }; + } + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + var o, + a = !0, + u = !1; + return { + s: function s() { + t = t.call(r); + }, + n: function n() { + var r = t.next(); + return a = r.done, r; + }, + e: function e(r) { + u = !0, o = r; + }, + f: function f() { + try { + a || null == t["return"] || t["return"](); + } finally { + if (u) throw o; + } + } + }; +} +module.exports = _createForOfIteratorHelper, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/createForOfIteratorHelperLoose.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/createForOfIteratorHelperLoose.js new file mode 100644 index 0000000000000000000000000000000000000000..bc81b1cdde61f8a7dc03cf50515a40cde569e849 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/createForOfIteratorHelperLoose.js @@ -0,0 +1,19 @@ +var unsupportedIterableToArray = require("./unsupportedIterableToArray.js"); +function _createForOfIteratorHelperLoose(r, e) { + var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; + if (t) return (t = t.call(r)).next.bind(t); + if (Array.isArray(r) || (t = unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { + t && (r = t); + var o = 0; + return function () { + return o >= r.length ? { + done: !0 + } : { + done: !1, + value: r[o++] + }; + }; + } + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} +module.exports = _createForOfIteratorHelperLoose, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/createSuper.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/createSuper.js new file mode 100644 index 0000000000000000000000000000000000000000..b1869e61bf956f2a95eeded35edd5b761692a8c3 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/createSuper.js @@ -0,0 +1,16 @@ +var getPrototypeOf = require("./getPrototypeOf.js"); +var isNativeReflectConstruct = require("./isNativeReflectConstruct.js"); +var possibleConstructorReturn = require("./possibleConstructorReturn.js"); +function _createSuper(t) { + var r = isNativeReflectConstruct(); + return function () { + var e, + o = getPrototypeOf(t); + if (r) { + var s = getPrototypeOf(this).constructor; + e = Reflect.construct(o, arguments, s); + } else e = o.apply(this, arguments); + return possibleConstructorReturn(this, e); + }; +} +module.exports = _createSuper, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/decorate.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/decorate.js new file mode 100644 index 0000000000000000000000000000000000000000..bc22acf4c52b25df128845c3e181d83722d3ad75 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/decorate.js @@ -0,0 +1,250 @@ +var toArray = require("./toArray.js"); +var toPropertyKey = require("./toPropertyKey.js"); +function _decorate(e, r, t, i) { + var o = _getDecoratorsApi(); + if (i) for (var n = 0; n < i.length; n++) o = i[n](o); + var s = r(function (e) { + o.initializeInstanceElements(e, a.elements); + }, t), + a = o.decorateClass(_coalesceClassElements(s.d.map(_createElementDescriptor)), e); + return o.initializeClassElements(s.F, a.elements), o.runClassFinishers(s.F, a.finishers); +} +function _getDecoratorsApi() { + _getDecoratorsApi = function _getDecoratorsApi() { + return e; + }; + var e = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function initializeInstanceElements(e, r) { + ["method", "field"].forEach(function (t) { + r.forEach(function (r) { + r.kind === t && "own" === r.placement && this.defineClassElement(e, r); + }, this); + }, this); + }, + initializeClassElements: function initializeClassElements(e, r) { + var t = e.prototype; + ["method", "field"].forEach(function (i) { + r.forEach(function (r) { + var o = r.placement; + if (r.kind === i && ("static" === o || "prototype" === o)) { + var n = "static" === o ? e : t; + this.defineClassElement(n, r); + } + }, this); + }, this); + }, + defineClassElement: function defineClassElement(e, r) { + var t = r.descriptor; + if ("field" === r.kind) { + var i = r.initializer; + t = { + enumerable: t.enumerable, + writable: t.writable, + configurable: t.configurable, + value: void 0 === i ? void 0 : i.call(e) + }; + } + Object.defineProperty(e, r.key, t); + }, + decorateClass: function decorateClass(e, r) { + var t = [], + i = [], + o = { + "static": [], + prototype: [], + own: [] + }; + if (e.forEach(function (e) { + this.addElementPlacement(e, o); + }, this), e.forEach(function (e) { + if (!_hasDecorators(e)) return t.push(e); + var r = this.decorateElement(e, o); + t.push(r.element), t.push.apply(t, r.extras), i.push.apply(i, r.finishers); + }, this), !r) return { + elements: t, + finishers: i + }; + var n = this.decorateConstructor(t, r); + return i.push.apply(i, n.finishers), n.finishers = i, n; + }, + addElementPlacement: function addElementPlacement(e, r, t) { + var i = r[e.placement]; + if (!t && -1 !== i.indexOf(e.key)) throw new TypeError("Duplicated element (" + e.key + ")"); + i.push(e.key); + }, + decorateElement: function decorateElement(e, r) { + for (var t = [], i = [], o = e.decorators, n = o.length - 1; n >= 0; n--) { + var s = r[e.placement]; + s.splice(s.indexOf(e.key), 1); + var a = this.fromElementDescriptor(e), + l = this.toElementFinisherExtras((0, o[n])(a) || a); + e = l.element, this.addElementPlacement(e, r), l.finisher && i.push(l.finisher); + var c = l.extras; + if (c) { + for (var p = 0; p < c.length; p++) this.addElementPlacement(c[p], r); + t.push.apply(t, c); + } + } + return { + element: e, + finishers: i, + extras: t + }; + }, + decorateConstructor: function decorateConstructor(e, r) { + for (var t = [], i = r.length - 1; i >= 0; i--) { + var o = this.fromClassDescriptor(e), + n = this.toClassDescriptor((0, r[i])(o) || o); + if (void 0 !== n.finisher && t.push(n.finisher), void 0 !== n.elements) { + e = n.elements; + for (var s = 0; s < e.length - 1; s++) for (var a = s + 1; a < e.length; a++) if (e[s].key === e[a].key && e[s].placement === e[a].placement) throw new TypeError("Duplicated element (" + e[s].key + ")"); + } + } + return { + elements: e, + finishers: t + }; + }, + fromElementDescriptor: function fromElementDescriptor(e) { + var r = { + kind: e.kind, + key: e.key, + placement: e.placement, + descriptor: e.descriptor + }; + return Object.defineProperty(r, Symbol.toStringTag, { + value: "Descriptor", + configurable: !0 + }), "field" === e.kind && (r.initializer = e.initializer), r; + }, + toElementDescriptors: function toElementDescriptors(e) { + if (void 0 !== e) return toArray(e).map(function (e) { + var r = this.toElementDescriptor(e); + return this.disallowProperty(e, "finisher", "An element descriptor"), this.disallowProperty(e, "extras", "An element descriptor"), r; + }, this); + }, + toElementDescriptor: function toElementDescriptor(e) { + var r = e.kind + ""; + if ("method" !== r && "field" !== r) throw new TypeError('An element descriptor\'s .kind property must be either "method" or "field", but a decorator created an element descriptor with .kind "' + r + '"'); + var t = toPropertyKey(e.key), + i = e.placement + ""; + if ("static" !== i && "prototype" !== i && "own" !== i) throw new TypeError('An element descriptor\'s .placement property must be one of "static", "prototype" or "own", but a decorator created an element descriptor with .placement "' + i + '"'); + var o = e.descriptor; + this.disallowProperty(e, "elements", "An element descriptor"); + var n = { + kind: r, + key: t, + placement: i, + descriptor: Object.assign({}, o) + }; + return "field" !== r ? this.disallowProperty(e, "initializer", "A method descriptor") : (this.disallowProperty(o, "get", "The property descriptor of a field descriptor"), this.disallowProperty(o, "set", "The property descriptor of a field descriptor"), this.disallowProperty(o, "value", "The property descriptor of a field descriptor"), n.initializer = e.initializer), n; + }, + toElementFinisherExtras: function toElementFinisherExtras(e) { + return { + element: this.toElementDescriptor(e), + finisher: _optionalCallableProperty(e, "finisher"), + extras: this.toElementDescriptors(e.extras) + }; + }, + fromClassDescriptor: function fromClassDescriptor(e) { + var r = { + kind: "class", + elements: e.map(this.fromElementDescriptor, this) + }; + return Object.defineProperty(r, Symbol.toStringTag, { + value: "Descriptor", + configurable: !0 + }), r; + }, + toClassDescriptor: function toClassDescriptor(e) { + var r = e.kind + ""; + if ("class" !== r) throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator created a class descriptor with .kind "' + r + '"'); + this.disallowProperty(e, "key", "A class descriptor"), this.disallowProperty(e, "placement", "A class descriptor"), this.disallowProperty(e, "descriptor", "A class descriptor"), this.disallowProperty(e, "initializer", "A class descriptor"), this.disallowProperty(e, "extras", "A class descriptor"); + var t = _optionalCallableProperty(e, "finisher"); + return { + elements: this.toElementDescriptors(e.elements), + finisher: t + }; + }, + runClassFinishers: function runClassFinishers(e, r) { + for (var t = 0; t < r.length; t++) { + var i = (0, r[t])(e); + if (void 0 !== i) { + if ("function" != typeof i) throw new TypeError("Finishers must return a constructor."); + e = i; + } + } + return e; + }, + disallowProperty: function disallowProperty(e, r, t) { + if (void 0 !== e[r]) throw new TypeError(t + " can't have a ." + r + " property."); + } + }; + return e; +} +function _createElementDescriptor(e) { + var r, + t = toPropertyKey(e.key); + "method" === e.kind ? r = { + value: e.value, + writable: !0, + configurable: !0, + enumerable: !1 + } : "get" === e.kind ? r = { + get: e.value, + configurable: !0, + enumerable: !1 + } : "set" === e.kind ? r = { + set: e.value, + configurable: !0, + enumerable: !1 + } : "field" === e.kind && (r = { + configurable: !0, + writable: !0, + enumerable: !0 + }); + var i = { + kind: "field" === e.kind ? "field" : "method", + key: t, + placement: e["static"] ? "static" : "field" === e.kind ? "own" : "prototype", + descriptor: r + }; + return e.decorators && (i.decorators = e.decorators), "field" === e.kind && (i.initializer = e.value), i; +} +function _coalesceGetterSetter(e, r) { + void 0 !== e.descriptor.get ? r.descriptor.get = e.descriptor.get : r.descriptor.set = e.descriptor.set; +} +function _coalesceClassElements(e) { + for (var r = [], isSameElement = function isSameElement(e) { + return "method" === e.kind && e.key === o.key && e.placement === o.placement; + }, t = 0; t < e.length; t++) { + var i, + o = e[t]; + if ("method" === o.kind && (i = r.find(isSameElement))) { + if (_isDataDescriptor(o.descriptor) || _isDataDescriptor(i.descriptor)) { + if (_hasDecorators(o) || _hasDecorators(i)) throw new ReferenceError("Duplicated methods (" + o.key + ") can't be decorated."); + i.descriptor = o.descriptor; + } else { + if (_hasDecorators(o)) { + if (_hasDecorators(i)) throw new ReferenceError("Decorators can't be placed on different accessors with for the same property (" + o.key + ")."); + i.decorators = o.decorators; + } + _coalesceGetterSetter(o, i); + } + } else r.push(o); + } + return r; +} +function _hasDecorators(e) { + return e.decorators && e.decorators.length; +} +function _isDataDescriptor(e) { + return void 0 !== e && !(void 0 === e.value && void 0 === e.writable); +} +function _optionalCallableProperty(e, r) { + var t = e[r]; + if (void 0 !== t && "function" != typeof t) throw new TypeError("Expected '" + r + "' to be a function"); + return t; +} +module.exports = _decorate, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/defaults.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/defaults.js new file mode 100644 index 0000000000000000000000000000000000000000..dfdbbb03a07bbc5d6472cf3cb2ab02c658964c3e --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/defaults.js @@ -0,0 +1,9 @@ +function _defaults(e, r) { + for (var t = Object.getOwnPropertyNames(r), o = 0; o < t.length; o++) { + var n = t[o], + a = Object.getOwnPropertyDescriptor(r, n); + a && a.configurable && void 0 === e[n] && Object.defineProperty(e, n, a); + } + return e; +} +module.exports = _defaults, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/defineAccessor.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/defineAccessor.js new file mode 100644 index 0000000000000000000000000000000000000000..dc065f01a850f4caec74ae3b2d9caf2891676610 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/defineAccessor.js @@ -0,0 +1,8 @@ +function _defineAccessor(e, r, n, t) { + var c = { + configurable: !0, + enumerable: !0 + }; + return c[e] = t, Object.defineProperty(r, n, c); +} +module.exports = _defineAccessor, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/defineEnumerableProperties.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/defineEnumerableProperties.js new file mode 100644 index 0000000000000000000000000000000000000000..ab9f43c1bf1f27c141fda30ecc7866b3ce5dd8f7 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/defineEnumerableProperties.js @@ -0,0 +1,12 @@ +function _defineEnumerableProperties(e, r) { + for (var t in r) { + var n = r[t]; + n.configurable = n.enumerable = !0, "value" in n && (n.writable = !0), Object.defineProperty(e, t, n); + } + if (Object.getOwnPropertySymbols) for (var a = Object.getOwnPropertySymbols(r), b = 0; b < a.length; b++) { + var i = a[b]; + (n = r[i]).configurable = n.enumerable = !0, "value" in n && (n.writable = !0), Object.defineProperty(e, i, n); + } + return e; +} +module.exports = _defineEnumerableProperties, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/defineProperty.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/defineProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..2c2ff1e98a72515db77b82f0eefad568b72bf466 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/defineProperty.js @@ -0,0 +1,10 @@ +var toPropertyKey = require("./toPropertyKey.js"); +function _defineProperty(e, r, t) { + return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, { + value: t, + enumerable: !0, + configurable: !0, + writable: !0 + }) : e[r] = t, e; +} +module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/dispose.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/dispose.js new file mode 100644 index 0000000000000000000000000000000000000000..c20193ca297707987f1baa822f36b983698ec8b1 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/dispose.js @@ -0,0 +1,28 @@ +function dispose_SuppressedError(r, e) { + return "undefined" != typeof SuppressedError ? dispose_SuppressedError = SuppressedError : (dispose_SuppressedError = function dispose_SuppressedError(r, e) { + this.suppressed = e, this.error = r, this.stack = Error().stack; + }, dispose_SuppressedError.prototype = Object.create(Error.prototype, { + constructor: { + value: dispose_SuppressedError, + writable: !0, + configurable: !0 + } + })), new dispose_SuppressedError(r, e); +} +function _dispose(r, e, s) { + function next() { + for (; r.length > 0;) try { + var o = r.pop(), + p = o.d.call(o.v); + if (o.a) return Promise.resolve(p).then(next, err); + } catch (r) { + return err(r); + } + if (s) throw e; + } + function err(r) { + return e = s ? new dispose_SuppressedError(e, r) : r, s = !0, next(); + } + return next(); +} +module.exports = _dispose, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/AwaitValue.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/AwaitValue.js new file mode 100644 index 0000000000000000000000000000000000000000..6f210c9ce8116b6f82fcd9ab00e915b3809d9831 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/AwaitValue.js @@ -0,0 +1,4 @@ +function _AwaitValue(t) { + this.wrapped = t; +} +export { _AwaitValue as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/OverloadYield.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/OverloadYield.js new file mode 100644 index 0000000000000000000000000000000000000000..d7753a6692fd20378b43e5dfad95d752a032df9e --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/OverloadYield.js @@ -0,0 +1,4 @@ +function _OverloadYield(e, d) { + this.v = e, this.k = d; +} +export { _OverloadYield as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecoratedDescriptor.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecoratedDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..0f33483df447503a18c25eaec9ee39e9467d05b5 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecoratedDescriptor.js @@ -0,0 +1,9 @@ +function _applyDecoratedDescriptor(i, e, r, n, l) { + var a = {}; + return Object.keys(n).forEach(function (i) { + a[i] = n[i]; + }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, ("value" in a || a.initializer) && (a.writable = !0), a = r.slice().reverse().reduce(function (r, n) { + return n(i, e, r) || r; + }, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a; +} +export { _applyDecoratedDescriptor as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs.js new file mode 100644 index 0000000000000000000000000000000000000000..2b75dfd7a6bfeb9bc5d792fb9edafa2763b5ffc3 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs.js @@ -0,0 +1,236 @@ +import _typeof from "./typeof.js"; +import setFunctionName from "./setFunctionName.js"; +import toPropertyKey from "./toPropertyKey.js"; +function old_createMetadataMethodsForProperty(e, t, a, r) { + return { + getMetadata: function getMetadata(o) { + old_assertNotFinished(r, "getMetadata"), old_assertMetadataKey(o); + var i = e[o]; + if (void 0 !== i) if (1 === t) { + var n = i["public"]; + if (void 0 !== n) return n[a]; + } else if (2 === t) { + var l = i["private"]; + if (void 0 !== l) return l.get(a); + } else if (Object.hasOwnProperty.call(i, "constructor")) return i.constructor; + }, + setMetadata: function setMetadata(o, i) { + old_assertNotFinished(r, "setMetadata"), old_assertMetadataKey(o); + var n = e[o]; + if (void 0 === n && (n = e[o] = {}), 1 === t) { + var l = n["public"]; + void 0 === l && (l = n["public"] = {}), l[a] = i; + } else if (2 === t) { + var s = n.priv; + void 0 === s && (s = n["private"] = new Map()), s.set(a, i); + } else n.constructor = i; + } + }; +} +function old_convertMetadataMapToFinal(e, t) { + var a = e[Symbol.metadata || Symbol["for"]("Symbol.metadata")], + r = Object.getOwnPropertySymbols(t); + if (0 !== r.length) { + for (var o = 0; o < r.length; o++) { + var i = r[o], + n = t[i], + l = a ? a[i] : null, + s = n["public"], + c = l ? l["public"] : null; + s && c && Object.setPrototypeOf(s, c); + var d = n["private"]; + if (d) { + var u = Array.from(d.values()), + f = l ? l["private"] : null; + f && (u = u.concat(f)), n["private"] = u; + } + l && Object.setPrototypeOf(n, l); + } + a && Object.setPrototypeOf(t, a), e[Symbol.metadata || Symbol["for"]("Symbol.metadata")] = t; + } +} +function old_createAddInitializerMethod(e, t) { + return function (a) { + old_assertNotFinished(t, "addInitializer"), old_assertCallable(a, "An initializer"), e.push(a); + }; +} +function old_memberDec(e, t, a, r, o, i, n, l, s) { + var c; + switch (i) { + case 1: + c = "accessor"; + break; + case 2: + c = "method"; + break; + case 3: + c = "getter"; + break; + case 4: + c = "setter"; + break; + default: + c = "field"; + } + var d, + u, + f = { + kind: c, + name: l ? "#" + t : toPropertyKey(t), + isStatic: n, + isPrivate: l + }, + p = { + v: !1 + }; + if (0 !== i && (f.addInitializer = old_createAddInitializerMethod(o, p)), l) { + d = 2, u = Symbol(t); + var v = {}; + 0 === i ? (v.get = a.get, v.set = a.set) : 2 === i ? v.get = function () { + return a.value; + } : (1 !== i && 3 !== i || (v.get = function () { + return a.get.call(this); + }), 1 !== i && 4 !== i || (v.set = function (e) { + a.set.call(this, e); + })), f.access = v; + } else d = 1, u = t; + try { + return e(s, Object.assign(f, old_createMetadataMethodsForProperty(r, d, u, p))); + } finally { + p.v = !0; + } +} +function old_assertNotFinished(e, t) { + if (e.v) throw Error("attempted to call " + t + " after decoration was finished"); +} +function old_assertMetadataKey(e) { + if ("symbol" != _typeof(e)) throw new TypeError("Metadata keys must be symbols, received: " + e); +} +function old_assertCallable(e, t) { + if ("function" != typeof e) throw new TypeError(t + " must be a function"); +} +function old_assertValidReturnValue(e, t) { + var a = _typeof(t); + if (1 === e) { + if ("object" !== a || null === t) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); + void 0 !== t.get && old_assertCallable(t.get, "accessor.get"), void 0 !== t.set && old_assertCallable(t.set, "accessor.set"), void 0 !== t.init && old_assertCallable(t.init, "accessor.init"), void 0 !== t.initializer && old_assertCallable(t.initializer, "accessor.initializer"); + } else if ("function" !== a) throw new TypeError((0 === e ? "field" : 10 === e ? "class" : "method") + " decorators must return a function or void 0"); +} +function old_getInit(e) { + var t; + return null == (t = e.init) && (t = e.initializer) && void 0 !== console && console.warn(".initializer has been renamed to .init as of March 2022"), t; +} +function old_applyMemberDec(e, t, a, r, o, i, n, l, s) { + var c, + d, + u, + f, + p, + v, + y, + h = a[0]; + if (n ? (0 === o || 1 === o ? (c = { + get: a[3], + set: a[4] + }, u = "get") : 3 === o ? (c = { + get: a[3] + }, u = "get") : 4 === o ? (c = { + set: a[3] + }, u = "set") : c = { + value: a[3] + }, 0 !== o && (1 === o && setFunctionName(a[4], "#" + r, "set"), setFunctionName(a[3], "#" + r, u))) : 0 !== o && (c = Object.getOwnPropertyDescriptor(t, r)), 1 === o ? f = { + get: c.get, + set: c.set + } : 2 === o ? f = c.value : 3 === o ? f = c.get : 4 === o && (f = c.set), "function" == typeof h) void 0 !== (p = old_memberDec(h, r, c, l, s, o, i, n, f)) && (old_assertValidReturnValue(o, p), 0 === o ? d = p : 1 === o ? (d = old_getInit(p), v = p.get || f.get, y = p.set || f.set, f = { + get: v, + set: y + }) : f = p);else for (var m = h.length - 1; m >= 0; m--) { + var b; + void 0 !== (p = old_memberDec(h[m], r, c, l, s, o, i, n, f)) && (old_assertValidReturnValue(o, p), 0 === o ? b = p : 1 === o ? (b = old_getInit(p), v = p.get || f.get, y = p.set || f.set, f = { + get: v, + set: y + }) : f = p, void 0 !== b && (void 0 === d ? d = b : "function" == typeof d ? d = [d, b] : d.push(b))); + } + if (0 === o || 1 === o) { + if (void 0 === d) d = function d(e, t) { + return t; + };else if ("function" != typeof d) { + var g = d; + d = function d(e, t) { + for (var a = t, r = 0; r < g.length; r++) a = g[r].call(e, a); + return a; + }; + } else { + var _ = d; + d = function d(e, t) { + return _.call(e, t); + }; + } + e.push(d); + } + 0 !== o && (1 === o ? (c.get = f.get, c.set = f.set) : 2 === o ? c.value = f : 3 === o ? c.get = f : 4 === o && (c.set = f), n ? 1 === o ? (e.push(function (e, t) { + return f.get.call(e, t); + }), e.push(function (e, t) { + return f.set.call(e, t); + })) : 2 === o ? e.push(f) : e.push(function (e, t) { + return f.call(e, t); + }) : Object.defineProperty(t, r, c)); +} +function old_applyMemberDecs(e, t, a, r, o) { + for (var i, n, l = new Map(), s = new Map(), c = 0; c < o.length; c++) { + var d = o[c]; + if (Array.isArray(d)) { + var u, + f, + p, + v = d[1], + y = d[2], + h = d.length > 3, + m = v >= 5; + if (m ? (u = t, f = r, 0 != (v -= 5) && (p = n = n || [])) : (u = t.prototype, f = a, 0 !== v && (p = i = i || [])), 0 !== v && !h) { + var b = m ? s : l, + g = b.get(y) || 0; + if (!0 === g || 3 === g && 4 !== v || 4 === g && 3 !== v) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + y); + !g && v > 2 ? b.set(y, v) : b.set(y, !0); + } + old_applyMemberDec(e, u, d, y, v, m, h, f, p); + } + } + old_pushInitializers(e, i), old_pushInitializers(e, n); +} +function old_pushInitializers(e, t) { + t && e.push(function (e) { + for (var a = 0; a < t.length; a++) t[a].call(e); + return e; + }); +} +function old_applyClassDecs(e, t, a, r) { + if (r.length > 0) { + for (var o = [], i = t, n = t.name, l = r.length - 1; l >= 0; l--) { + var s = { + v: !1 + }; + try { + var c = Object.assign({ + kind: "class", + name: n, + addInitializer: old_createAddInitializerMethod(o, s) + }, old_createMetadataMethodsForProperty(a, 0, n, s)), + d = r[l](i, c); + } finally { + s.v = !0; + } + void 0 !== d && (old_assertValidReturnValue(10, d), i = d); + } + e.push(i, function () { + for (var e = 0; e < o.length; e++) o[e].call(i); + }); + } +} +function applyDecs(e, t, a) { + var r = [], + o = {}, + i = {}; + return old_applyMemberDecs(r, e, i, o, t), old_convertMetadataMapToFinal(e.prototype, i), old_applyClassDecs(r, e, o, a), old_convertMetadataMapToFinal(e, o), r; +} +export { applyDecs as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs2203.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs2203.js new file mode 100644 index 0000000000000000000000000000000000000000..bddb51d072d084e913659a71700eace25e4477b2 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs2203.js @@ -0,0 +1,184 @@ +import _typeof from "./typeof.js"; +function applyDecs2203Factory() { + function createAddInitializerMethod(e, t) { + return function (r) { + !function (e, t) { + if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); + }(t), assertCallable(r, "An initializer"), e.push(r); + }; + } + function memberDec(e, t, r, a, n, i, s, o) { + var c; + switch (n) { + case 1: + c = "accessor"; + break; + case 2: + c = "method"; + break; + case 3: + c = "getter"; + break; + case 4: + c = "setter"; + break; + default: + c = "field"; + } + var l, + u, + f = { + kind: c, + name: s ? "#" + t : t, + "static": i, + "private": s + }, + p = { + v: !1 + }; + 0 !== n && (f.addInitializer = createAddInitializerMethod(a, p)), 0 === n ? s ? (l = r.get, u = r.set) : (l = function l() { + return this[t]; + }, u = function u(e) { + this[t] = e; + }) : 2 === n ? l = function l() { + return r.value; + } : (1 !== n && 3 !== n || (l = function l() { + return r.get.call(this); + }), 1 !== n && 4 !== n || (u = function u(e) { + r.set.call(this, e); + })), f.access = l && u ? { + get: l, + set: u + } : l ? { + get: l + } : { + set: u + }; + try { + return e(o, f); + } finally { + p.v = !0; + } + } + function assertCallable(e, t) { + if ("function" != typeof e) throw new TypeError(t + " must be a function"); + } + function assertValidReturnValue(e, t) { + var r = _typeof(t); + if (1 === e) { + if ("object" !== r || null === t) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); + void 0 !== t.get && assertCallable(t.get, "accessor.get"), void 0 !== t.set && assertCallable(t.set, "accessor.set"), void 0 !== t.init && assertCallable(t.init, "accessor.init"); + } else if ("function" !== r) throw new TypeError((0 === e ? "field" : 10 === e ? "class" : "method") + " decorators must return a function or void 0"); + } + function applyMemberDec(e, t, r, a, n, i, s, o) { + var c, + l, + u, + f, + p, + d, + h = r[0]; + if (s ? c = 0 === n || 1 === n ? { + get: r[3], + set: r[4] + } : 3 === n ? { + get: r[3] + } : 4 === n ? { + set: r[3] + } : { + value: r[3] + } : 0 !== n && (c = Object.getOwnPropertyDescriptor(t, a)), 1 === n ? u = { + get: c.get, + set: c.set + } : 2 === n ? u = c.value : 3 === n ? u = c.get : 4 === n && (u = c.set), "function" == typeof h) void 0 !== (f = memberDec(h, a, c, o, n, i, s, u)) && (assertValidReturnValue(n, f), 0 === n ? l = f : 1 === n ? (l = f.init, p = f.get || u.get, d = f.set || u.set, u = { + get: p, + set: d + }) : u = f);else for (var v = h.length - 1; v >= 0; v--) { + var g; + void 0 !== (f = memberDec(h[v], a, c, o, n, i, s, u)) && (assertValidReturnValue(n, f), 0 === n ? g = f : 1 === n ? (g = f.init, p = f.get || u.get, d = f.set || u.set, u = { + get: p, + set: d + }) : u = f, void 0 !== g && (void 0 === l ? l = g : "function" == typeof l ? l = [l, g] : l.push(g))); + } + if (0 === n || 1 === n) { + if (void 0 === l) l = function l(e, t) { + return t; + };else if ("function" != typeof l) { + var y = l; + l = function l(e, t) { + for (var r = t, a = 0; a < y.length; a++) r = y[a].call(e, r); + return r; + }; + } else { + var m = l; + l = function l(e, t) { + return m.call(e, t); + }; + } + e.push(l); + } + 0 !== n && (1 === n ? (c.get = u.get, c.set = u.set) : 2 === n ? c.value = u : 3 === n ? c.get = u : 4 === n && (c.set = u), s ? 1 === n ? (e.push(function (e, t) { + return u.get.call(e, t); + }), e.push(function (e, t) { + return u.set.call(e, t); + })) : 2 === n ? e.push(u) : e.push(function (e, t) { + return u.call(e, t); + }) : Object.defineProperty(t, a, c)); + } + function pushInitializers(e, t) { + t && e.push(function (e) { + for (var r = 0; r < t.length; r++) t[r].call(e); + return e; + }); + } + return function (e, t, r) { + var a = []; + return function (e, t, r) { + for (var a, n, i = new Map(), s = new Map(), o = 0; o < r.length; o++) { + var c = r[o]; + if (Array.isArray(c)) { + var l, + u, + f = c[1], + p = c[2], + d = c.length > 3, + h = f >= 5; + if (h ? (l = t, 0 != (f -= 5) && (u = n = n || [])) : (l = t.prototype, 0 !== f && (u = a = a || [])), 0 !== f && !d) { + var v = h ? s : i, + g = v.get(p) || 0; + if (!0 === g || 3 === g && 4 !== f || 4 === g && 3 !== f) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + p); + !g && f > 2 ? v.set(p, f) : v.set(p, !0); + } + applyMemberDec(e, l, c, p, f, h, d, u); + } + } + pushInitializers(e, a), pushInitializers(e, n); + }(a, e, t), function (e, t, r) { + if (r.length > 0) { + for (var a = [], n = t, i = t.name, s = r.length - 1; s >= 0; s--) { + var o = { + v: !1 + }; + try { + var c = r[s](n, { + kind: "class", + name: i, + addInitializer: createAddInitializerMethod(a, o) + }); + } finally { + o.v = !0; + } + void 0 !== c && (assertValidReturnValue(10, c), n = c); + } + e.push(n, function () { + for (var e = 0; e < a.length; e++) a[e].call(n); + }); + } + }(a, e, r), a; + }; +} +var applyDecs2203Impl; +function applyDecs2203(e, t, r) { + return (applyDecs2203Impl = applyDecs2203Impl || applyDecs2203Factory())(e, t, r); +} +export { applyDecs2203 as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs2203R.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs2203R.js new file mode 100644 index 0000000000000000000000000000000000000000..3944bf428504e025e0eeaf47df3256479a2a2147 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs2203R.js @@ -0,0 +1,191 @@ +import _typeof from "./typeof.js"; +import setFunctionName from "./setFunctionName.js"; +import toPropertyKey from "./toPropertyKey.js"; +function applyDecs2203RFactory() { + function createAddInitializerMethod(e, t) { + return function (r) { + !function (e, t) { + if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); + }(t), assertCallable(r, "An initializer"), e.push(r); + }; + } + function memberDec(e, t, r, n, a, i, o, s) { + var c; + switch (a) { + case 1: + c = "accessor"; + break; + case 2: + c = "method"; + break; + case 3: + c = "getter"; + break; + case 4: + c = "setter"; + break; + default: + c = "field"; + } + var l, + u, + f = { + kind: c, + name: o ? "#" + t : toPropertyKey(t), + "static": i, + "private": o + }, + p = { + v: !1 + }; + 0 !== a && (f.addInitializer = createAddInitializerMethod(n, p)), 0 === a ? o ? (l = r.get, u = r.set) : (l = function l() { + return this[t]; + }, u = function u(e) { + this[t] = e; + }) : 2 === a ? l = function l() { + return r.value; + } : (1 !== a && 3 !== a || (l = function l() { + return r.get.call(this); + }), 1 !== a && 4 !== a || (u = function u(e) { + r.set.call(this, e); + })), f.access = l && u ? { + get: l, + set: u + } : l ? { + get: l + } : { + set: u + }; + try { + return e(s, f); + } finally { + p.v = !0; + } + } + function assertCallable(e, t) { + if ("function" != typeof e) throw new TypeError(t + " must be a function"); + } + function assertValidReturnValue(e, t) { + var r = _typeof(t); + if (1 === e) { + if ("object" !== r || null === t) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); + void 0 !== t.get && assertCallable(t.get, "accessor.get"), void 0 !== t.set && assertCallable(t.set, "accessor.set"), void 0 !== t.init && assertCallable(t.init, "accessor.init"); + } else if ("function" !== r) throw new TypeError((0 === e ? "field" : 10 === e ? "class" : "method") + " decorators must return a function or void 0"); + } + function applyMemberDec(e, t, r, n, a, i, o, s) { + var c, + l, + u, + f, + p, + d, + h, + v = r[0]; + if (o ? (0 === a || 1 === a ? (c = { + get: r[3], + set: r[4] + }, u = "get") : 3 === a ? (c = { + get: r[3] + }, u = "get") : 4 === a ? (c = { + set: r[3] + }, u = "set") : c = { + value: r[3] + }, 0 !== a && (1 === a && setFunctionName(r[4], "#" + n, "set"), setFunctionName(r[3], "#" + n, u))) : 0 !== a && (c = Object.getOwnPropertyDescriptor(t, n)), 1 === a ? f = { + get: c.get, + set: c.set + } : 2 === a ? f = c.value : 3 === a ? f = c.get : 4 === a && (f = c.set), "function" == typeof v) void 0 !== (p = memberDec(v, n, c, s, a, i, o, f)) && (assertValidReturnValue(a, p), 0 === a ? l = p : 1 === a ? (l = p.init, d = p.get || f.get, h = p.set || f.set, f = { + get: d, + set: h + }) : f = p);else for (var g = v.length - 1; g >= 0; g--) { + var y; + void 0 !== (p = memberDec(v[g], n, c, s, a, i, o, f)) && (assertValidReturnValue(a, p), 0 === a ? y = p : 1 === a ? (y = p.init, d = p.get || f.get, h = p.set || f.set, f = { + get: d, + set: h + }) : f = p, void 0 !== y && (void 0 === l ? l = y : "function" == typeof l ? l = [l, y] : l.push(y))); + } + if (0 === a || 1 === a) { + if (void 0 === l) l = function l(e, t) { + return t; + };else if ("function" != typeof l) { + var m = l; + l = function l(e, t) { + for (var r = t, n = 0; n < m.length; n++) r = m[n].call(e, r); + return r; + }; + } else { + var b = l; + l = function l(e, t) { + return b.call(e, t); + }; + } + e.push(l); + } + 0 !== a && (1 === a ? (c.get = f.get, c.set = f.set) : 2 === a ? c.value = f : 3 === a ? c.get = f : 4 === a && (c.set = f), o ? 1 === a ? (e.push(function (e, t) { + return f.get.call(e, t); + }), e.push(function (e, t) { + return f.set.call(e, t); + })) : 2 === a ? e.push(f) : e.push(function (e, t) { + return f.call(e, t); + }) : Object.defineProperty(t, n, c)); + } + function applyMemberDecs(e, t) { + for (var r, n, a = [], i = new Map(), o = new Map(), s = 0; s < t.length; s++) { + var c = t[s]; + if (Array.isArray(c)) { + var l, + u, + f = c[1], + p = c[2], + d = c.length > 3, + h = f >= 5; + if (h ? (l = e, 0 != (f -= 5) && (u = n = n || [])) : (l = e.prototype, 0 !== f && (u = r = r || [])), 0 !== f && !d) { + var v = h ? o : i, + g = v.get(p) || 0; + if (!0 === g || 3 === g && 4 !== f || 4 === g && 3 !== f) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + p); + !g && f > 2 ? v.set(p, f) : v.set(p, !0); + } + applyMemberDec(a, l, c, p, f, h, d, u); + } + } + return pushInitializers(a, r), pushInitializers(a, n), a; + } + function pushInitializers(e, t) { + t && e.push(function (e) { + for (var r = 0; r < t.length; r++) t[r].call(e); + return e; + }); + } + return function (e, t, r) { + return { + e: applyMemberDecs(e, t), + get c() { + return function (e, t) { + if (t.length > 0) { + for (var r = [], n = e, a = e.name, i = t.length - 1; i >= 0; i--) { + var o = { + v: !1 + }; + try { + var s = t[i](n, { + kind: "class", + name: a, + addInitializer: createAddInitializerMethod(r, o) + }); + } finally { + o.v = !0; + } + void 0 !== s && (assertValidReturnValue(10, s), n = s); + } + return [n, function () { + for (var e = 0; e < r.length; e++) r[e].call(n); + }]; + } + }(e, r); + } + }; + }; +} +function applyDecs2203R(e, t, r) { + return (applyDecs2203R = applyDecs2203RFactory())(e, t, r); +} +export { applyDecs2203R as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs2301.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs2301.js new file mode 100644 index 0000000000000000000000000000000000000000..bb4fbe6a9b642d422cca27cc22e6d797ef43a21f --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs2301.js @@ -0,0 +1,222 @@ +import _typeof from "./typeof.js"; +import checkInRHS from "./checkInRHS.js"; +import setFunctionName from "./setFunctionName.js"; +import toPropertyKey from "./toPropertyKey.js"; +function applyDecs2301Factory() { + function createAddInitializerMethod(e, t) { + return function (r) { + !function (e, t) { + if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); + }(t), assertCallable(r, "An initializer"), e.push(r); + }; + } + function assertInstanceIfPrivate(e, t) { + if (!e(t)) throw new TypeError("Attempted to access private element on non-instance"); + } + function memberDec(e, t, r, n, a, i, s, o, c) { + var u; + switch (a) { + case 1: + u = "accessor"; + break; + case 2: + u = "method"; + break; + case 3: + u = "getter"; + break; + case 4: + u = "setter"; + break; + default: + u = "field"; + } + var l, + f, + p = { + kind: u, + name: s ? "#" + t : toPropertyKey(t), + "static": i, + "private": s + }, + d = { + v: !1 + }; + if (0 !== a && (p.addInitializer = createAddInitializerMethod(n, d)), s || 0 !== a && 2 !== a) { + if (2 === a) l = function l(e) { + return assertInstanceIfPrivate(c, e), r.value; + };else { + var h = 0 === a || 1 === a; + (h || 3 === a) && (l = s ? function (e) { + return assertInstanceIfPrivate(c, e), r.get.call(e); + } : function (e) { + return r.get.call(e); + }), (h || 4 === a) && (f = s ? function (e, t) { + assertInstanceIfPrivate(c, e), r.set.call(e, t); + } : function (e, t) { + r.set.call(e, t); + }); + } + } else l = function l(e) { + return e[t]; + }, 0 === a && (f = function f(e, r) { + e[t] = r; + }); + var v = s ? c.bind() : function (e) { + return t in e; + }; + p.access = l && f ? { + get: l, + set: f, + has: v + } : l ? { + get: l, + has: v + } : { + set: f, + has: v + }; + try { + return e(o, p); + } finally { + d.v = !0; + } + } + function assertCallable(e, t) { + if ("function" != typeof e) throw new TypeError(t + " must be a function"); + } + function assertValidReturnValue(e, t) { + var r = _typeof(t); + if (1 === e) { + if ("object" !== r || null === t) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); + void 0 !== t.get && assertCallable(t.get, "accessor.get"), void 0 !== t.set && assertCallable(t.set, "accessor.set"), void 0 !== t.init && assertCallable(t.init, "accessor.init"); + } else if ("function" !== r) throw new TypeError((0 === e ? "field" : 10 === e ? "class" : "method") + " decorators must return a function or void 0"); + } + function curryThis2(e) { + return function (t) { + e(this, t); + }; + } + function applyMemberDec(e, t, r, n, a, i, s, o, c) { + var u, + l, + f, + p, + d, + h, + v, + y, + g = r[0]; + if (s ? (0 === a || 1 === a ? (u = { + get: (d = r[3], function () { + return d(this); + }), + set: curryThis2(r[4]) + }, f = "get") : 3 === a ? (u = { + get: r[3] + }, f = "get") : 4 === a ? (u = { + set: r[3] + }, f = "set") : u = { + value: r[3] + }, 0 !== a && (1 === a && setFunctionName(u.set, "#" + n, "set"), setFunctionName(u[f || "value"], "#" + n, f))) : 0 !== a && (u = Object.getOwnPropertyDescriptor(t, n)), 1 === a ? p = { + get: u.get, + set: u.set + } : 2 === a ? p = u.value : 3 === a ? p = u.get : 4 === a && (p = u.set), "function" == typeof g) void 0 !== (h = memberDec(g, n, u, o, a, i, s, p, c)) && (assertValidReturnValue(a, h), 0 === a ? l = h : 1 === a ? (l = h.init, v = h.get || p.get, y = h.set || p.set, p = { + get: v, + set: y + }) : p = h);else for (var m = g.length - 1; m >= 0; m--) { + var b; + void 0 !== (h = memberDec(g[m], n, u, o, a, i, s, p, c)) && (assertValidReturnValue(a, h), 0 === a ? b = h : 1 === a ? (b = h.init, v = h.get || p.get, y = h.set || p.set, p = { + get: v, + set: y + }) : p = h, void 0 !== b && (void 0 === l ? l = b : "function" == typeof l ? l = [l, b] : l.push(b))); + } + if (0 === a || 1 === a) { + if (void 0 === l) l = function l(e, t) { + return t; + };else if ("function" != typeof l) { + var I = l; + l = function l(e, t) { + for (var r = t, n = 0; n < I.length; n++) r = I[n].call(e, r); + return r; + }; + } else { + var w = l; + l = function l(e, t) { + return w.call(e, t); + }; + } + e.push(l); + } + 0 !== a && (1 === a ? (u.get = p.get, u.set = p.set) : 2 === a ? u.value = p : 3 === a ? u.get = p : 4 === a && (u.set = p), s ? 1 === a ? (e.push(function (e, t) { + return p.get.call(e, t); + }), e.push(function (e, t) { + return p.set.call(e, t); + })) : 2 === a ? e.push(p) : e.push(function (e, t) { + return p.call(e, t); + }) : Object.defineProperty(t, n, u)); + } + function applyMemberDecs(e, t, r) { + for (var n, a, i, s = [], o = new Map(), c = new Map(), u = 0; u < t.length; u++) { + var l = t[u]; + if (Array.isArray(l)) { + var f, + p, + d = l[1], + h = l[2], + v = l.length > 3, + y = d >= 5, + g = r; + if (y ? (f = e, 0 != (d -= 5) && (p = a = a || []), v && !i && (i = function i(t) { + return checkInRHS(t) === e; + }), g = i) : (f = e.prototype, 0 !== d && (p = n = n || [])), 0 !== d && !v) { + var m = y ? c : o, + b = m.get(h) || 0; + if (!0 === b || 3 === b && 4 !== d || 4 === b && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); + !b && d > 2 ? m.set(h, d) : m.set(h, !0); + } + applyMemberDec(s, f, l, h, d, y, v, p, g); + } + } + return pushInitializers(s, n), pushInitializers(s, a), s; + } + function pushInitializers(e, t) { + t && e.push(function (e) { + for (var r = 0; r < t.length; r++) t[r].call(e); + return e; + }); + } + return function (e, t, r, n) { + return { + e: applyMemberDecs(e, t, n), + get c() { + return function (e, t) { + if (t.length > 0) { + for (var r = [], n = e, a = e.name, i = t.length - 1; i >= 0; i--) { + var s = { + v: !1 + }; + try { + var o = t[i](n, { + kind: "class", + name: a, + addInitializer: createAddInitializerMethod(r, s) + }); + } finally { + s.v = !0; + } + void 0 !== o && (assertValidReturnValue(10, o), n = o); + } + return [n, function () { + for (var e = 0; e < r.length; e++) r[e].call(n); + }]; + } + }(e, r); + } + }; + }; +} +function applyDecs2301(e, t, r, n) { + return (applyDecs2301 = applyDecs2301Factory())(e, t, r, n); +} +export { applyDecs2301 as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs2305.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs2305.js new file mode 100644 index 0000000000000000000000000000000000000000..a11b2b90c15b47a633782d266eb25b50ee7435f5 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs2305.js @@ -0,0 +1,133 @@ +import _typeof from "./typeof.js"; +import checkInRHS from "./checkInRHS.js"; +import setFunctionName from "./setFunctionName.js"; +import toPropertyKey from "./toPropertyKey.js"; +function applyDecs2305(e, t, r, n, o, a) { + function i(e, t, r) { + return function (n, o) { + return r && r(n), e[t].call(n, o); + }; + } + function c(e, t) { + for (var r = 0; r < e.length; r++) e[r].call(t); + return t; + } + function s(e, t, r, n) { + if ("function" != typeof e && (n || void 0 !== e)) throw new TypeError(t + " must " + (r || "be") + " a function" + (n ? "" : " or undefined")); + return e; + } + function applyDec(e, t, r, n, o, a, c, u, l, f, p, d, h) { + function m(e) { + if (!h(e)) throw new TypeError("Attempted to access private element on non-instance"); + } + var y, + v = t[0], + g = t[3], + b = !u; + if (!b) { + r || Array.isArray(v) || (v = [v]); + var w = {}, + S = [], + A = 3 === o ? "get" : 4 === o || d ? "set" : "value"; + f ? (p || d ? w = { + get: setFunctionName(function () { + return g(this); + }, n, "get"), + set: function set(e) { + t[4](this, e); + } + } : w[A] = g, p || setFunctionName(w[A], n, 2 === o ? "" : A)) : p || (w = Object.getOwnPropertyDescriptor(e, n)); + } + for (var P = e, j = v.length - 1; j >= 0; j -= r ? 2 : 1) { + var D = v[j], + E = r ? v[j - 1] : void 0, + I = {}, + O = { + kind: ["field", "accessor", "method", "getter", "setter", "class"][o], + name: n, + metadata: a, + addInitializer: function (e, t) { + if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); + s(t, "An initializer", "be", !0), c.push(t); + }.bind(null, I) + }; + try { + if (b) (y = s(D.call(E, P, O), "class decorators", "return")) && (P = y);else { + var k, F; + O["static"] = l, O["private"] = f, f ? 2 === o ? k = function k(e) { + return m(e), w.value; + } : (o < 4 && (k = i(w, "get", m)), 3 !== o && (F = i(w, "set", m))) : (k = function k(e) { + return e[n]; + }, (o < 2 || 4 === o) && (F = function F(e, t) { + e[n] = t; + })); + var N = O.access = { + has: f ? h.bind() : function (e) { + return n in e; + } + }; + if (k && (N.get = k), F && (N.set = F), P = D.call(E, d ? { + get: w.get, + set: w.set + } : w[A], O), d) { + if ("object" == _typeof(P) && P) (y = s(P.get, "accessor.get")) && (w.get = y), (y = s(P.set, "accessor.set")) && (w.set = y), (y = s(P.init, "accessor.init")) && S.push(y);else if (void 0 !== P) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); + } else s(P, (p ? "field" : "method") + " decorators", "return") && (p ? S.push(P) : w[A] = P); + } + } finally { + I.v = !0; + } + } + return (p || d) && u.push(function (e, t) { + for (var r = S.length - 1; r >= 0; r--) t = S[r].call(e, t); + return t; + }), p || b || (f ? d ? u.push(i(w, "get"), i(w, "set")) : u.push(2 === o ? w[A] : i.call.bind(w[A])) : Object.defineProperty(e, n, w)), P; + } + function u(e, t) { + return Object.defineProperty(e, Symbol.metadata || Symbol["for"]("Symbol.metadata"), { + configurable: !0, + enumerable: !0, + value: t + }); + } + if (arguments.length >= 6) var l = a[Symbol.metadata || Symbol["for"]("Symbol.metadata")]; + var f = Object.create(null == l ? null : l), + p = function (e, t, r, n) { + var o, + a, + i = [], + s = function s(t) { + return checkInRHS(t) === e; + }, + u = new Map(); + function l(e) { + e && i.push(c.bind(null, e)); + } + for (var f = 0; f < t.length; f++) { + var p = t[f]; + if (Array.isArray(p)) { + var d = p[1], + h = p[2], + m = p.length > 3, + y = 16 & d, + v = !!(8 & d), + g = 0 == (d &= 7), + b = h + "/" + v; + if (!g && !m) { + var w = u.get(b); + if (!0 === w || 3 === w && 4 !== d || 4 === w && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); + u.set(b, !(d > 2) || d); + } + applyDec(v ? e : e.prototype, p, y, m ? "#" + h : toPropertyKey(h), d, n, v ? a = a || [] : o = o || [], i, v, m, g, 1 === d, v && m ? s : r); + } + } + return l(o), l(a), i; + }(e, t, o, f); + return r.length || u(e, f), { + e: p, + get c() { + var t = []; + return r.length && [u(applyDec(e, [r], n, e.name, 5, f, t), f), c.bind(null, t, e)]; + } + }; +} +export { applyDecs2305 as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs2311.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs2311.js new file mode 100644 index 0000000000000000000000000000000000000000..41b2c4848f177a0c741303ddc5f222a65c067dc2 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/applyDecs2311.js @@ -0,0 +1,124 @@ +import _typeof from "./typeof.js"; +import checkInRHS from "./checkInRHS.js"; +import setFunctionName from "./setFunctionName.js"; +import toPropertyKey from "./toPropertyKey.js"; +function applyDecs2311(e, t, n, r, o, i) { + var a, + c, + u, + s, + f, + l, + p, + d = Symbol.metadata || Symbol["for"]("Symbol.metadata"), + m = Object.defineProperty, + h = Object.create, + y = [h(null), h(null)], + v = t.length; + function g(t, n, r) { + return function (o, i) { + n && (i = o, o = e); + for (var a = 0; a < t.length; a++) i = t[a].apply(o, r ? [i] : []); + return r ? i : o; + }; + } + function b(e, t, n, r) { + if ("function" != typeof e && (r || void 0 !== e)) throw new TypeError(t + " must " + (n || "be") + " a function" + (r ? "" : " or undefined")); + return e; + } + function applyDec(e, t, n, r, o, i, u, s, f, l, p) { + function d(e) { + if (!p(e)) throw new TypeError("Attempted to access private element on non-instance"); + } + var h = [].concat(t[0]), + v = t[3], + w = !u, + D = 1 === o, + S = 3 === o, + j = 4 === o, + E = 2 === o; + function I(t, n, r) { + return function (o, i) { + return n && (i = o, o = e), r && r(o), P[t].call(o, i); + }; + } + if (!w) { + var P = {}, + k = [], + F = S ? "get" : j || D ? "set" : "value"; + if (f ? (l || D ? P = { + get: setFunctionName(function () { + return v(this); + }, r, "get"), + set: function set(e) { + t[4](this, e); + } + } : P[F] = v, l || setFunctionName(P[F], r, E ? "" : F)) : l || (P = Object.getOwnPropertyDescriptor(e, r)), !l && !f) { + if ((c = y[+s][r]) && 7 != (c ^ o)) throw Error("Decorating two elements with the same name (" + P[F].name + ") is not supported yet"); + y[+s][r] = o < 3 ? 1 : o; + } + } + for (var N = e, O = h.length - 1; O >= 0; O -= n ? 2 : 1) { + var T = b(h[O], "A decorator", "be", !0), + z = n ? h[O - 1] : void 0, + A = {}, + H = { + kind: ["field", "accessor", "method", "getter", "setter", "class"][o], + name: r, + metadata: a, + addInitializer: function (e, t) { + if (e.v) throw new TypeError("attempted to call addInitializer after decoration was finished"); + b(t, "An initializer", "be", !0), i.push(t); + }.bind(null, A) + }; + if (w) c = T.call(z, N, H), A.v = 1, b(c, "class decorators", "return") && (N = c);else if (H["static"] = s, H["private"] = f, c = H.access = { + has: f ? p.bind() : function (e) { + return r in e; + } + }, j || (c.get = f ? E ? function (e) { + return d(e), P.value; + } : I("get", 0, d) : function (e) { + return e[r]; + }), E || S || (c.set = f ? I("set", 0, d) : function (e, t) { + e[r] = t; + }), N = T.call(z, D ? { + get: P.get, + set: P.set + } : P[F], H), A.v = 1, D) { + if ("object" == _typeof(N) && N) (c = b(N.get, "accessor.get")) && (P.get = c), (c = b(N.set, "accessor.set")) && (P.set = c), (c = b(N.init, "accessor.init")) && k.unshift(c);else if (void 0 !== N) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined"); + } else b(N, (l ? "field" : "method") + " decorators", "return") && (l ? k.unshift(N) : P[F] = N); + } + return o < 2 && u.push(g(k, s, 1), g(i, s, 0)), l || w || (f ? D ? u.splice(-1, 0, I("get", s), I("set", s)) : u.push(E ? P[F] : b.call.bind(P[F])) : m(e, r, P)), N; + } + function w(e) { + return m(e, d, { + configurable: !0, + enumerable: !0, + value: a + }); + } + return void 0 !== i && (a = i[d]), a = h(null == a ? null : a), f = [], l = function l(e) { + e && f.push(g(e)); + }, p = function p(t, r) { + for (var i = 0; i < n.length; i++) { + var a = n[i], + c = a[1], + l = 7 & c; + if ((8 & c) == t && !l == r) { + var p = a[2], + d = !!a[3], + m = 16 & c; + applyDec(t ? e : e.prototype, a, m, d ? "#" + p : toPropertyKey(p), l, l < 2 ? [] : t ? s = s || [] : u = u || [], f, !!t, d, r, t && d ? function (t) { + return checkInRHS(t) === e; + } : o); + } + } + }, p(8, 0), p(0, 0), p(8, 1), p(0, 1), l(u), l(s), c = f, v || w(e), { + e: c, + get c() { + var n = []; + return v && [w(e = applyDec(e, [t], r, e.name, 5, n)), g(n, 1)]; + } + }; +} +export { applyDecs2311 as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js new file mode 100644 index 0000000000000000000000000000000000000000..9ace77240f113e563a5981101b1ee755e57b40ad --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js @@ -0,0 +1,6 @@ +function _arrayLikeToArray(r, a) { + (null == a || a > r.length) && (a = r.length); + for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; + return n; +} +export { _arrayLikeToArray as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js new file mode 100644 index 0000000000000000000000000000000000000000..99fa715408e037f9d406c0a8329c88537b96dcd5 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js @@ -0,0 +1,4 @@ +function _arrayWithHoles(r) { + if (Array.isArray(r)) return r; +} +export { _arrayWithHoles as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js new file mode 100644 index 0000000000000000000000000000000000000000..1ce6f21462eddcd3a6cc5c00d3c14606339cfa54 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js @@ -0,0 +1,5 @@ +import arrayLikeToArray from "./arrayLikeToArray.js"; +function _arrayWithoutHoles(r) { + if (Array.isArray(r)) return arrayLikeToArray(r); +} +export { _arrayWithoutHoles as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/assertClassBrand.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/assertClassBrand.js new file mode 100644 index 0000000000000000000000000000000000000000..ae7b712606d7ffadba8e483fa5453847ad960294 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/assertClassBrand.js @@ -0,0 +1,5 @@ +function _assertClassBrand(e, t, n) { + if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; + throw new TypeError("Private element is not present on this object"); +} +export { _assertClassBrand as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js new file mode 100644 index 0000000000000000000000000000000000000000..4a41bde6268a764057eaa9947897ef516e4c7423 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js @@ -0,0 +1,5 @@ +function _assertThisInitialized(e) { + if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + return e; +} +export { _assertThisInitialized as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/asyncGeneratorDelegate.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/asyncGeneratorDelegate.js new file mode 100644 index 0000000000000000000000000000000000000000..e0266897d53faaf9191c8c0472e5c0118af6ff68 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/asyncGeneratorDelegate.js @@ -0,0 +1,24 @@ +import OverloadYield from "./OverloadYield.js"; +function _asyncGeneratorDelegate(t) { + var e = {}, + n = !1; + function pump(e, r) { + return n = !0, r = new Promise(function (n) { + n(t[e](r)); + }), { + done: !1, + value: new OverloadYield(r, 1) + }; + } + return e["undefined" != typeof Symbol && Symbol.iterator || "@@iterator"] = function () { + return this; + }, e.next = function (t) { + return n ? (n = !1, t) : pump("next", t); + }, "function" == typeof t["throw"] && (e["throw"] = function (t) { + if (n) throw n = !1, t; + return pump("throw", t); + }), "function" == typeof t["return"] && (e["return"] = function (t) { + return n ? (n = !1, t) : pump("return", t); + }), e; +} +export { _asyncGeneratorDelegate as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/asyncIterator.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/asyncIterator.js new file mode 100644 index 0000000000000000000000000000000000000000..2ed00b796f497a14b96f1b9799d06e7f698b8ecf --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/asyncIterator.js @@ -0,0 +1,45 @@ +function _asyncIterator(r) { + var n, + t, + o, + e = 2; + for ("undefined" != typeof Symbol && (t = Symbol.asyncIterator, o = Symbol.iterator); e--;) { + if (t && null != (n = r[t])) return n.call(r); + if (o && null != (n = r[o])) return new AsyncFromSyncIterator(n.call(r)); + t = "@@asyncIterator", o = "@@iterator"; + } + throw new TypeError("Object is not async iterable"); +} +function AsyncFromSyncIterator(r) { + function AsyncFromSyncIteratorContinuation(r) { + if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object.")); + var n = r.done; + return Promise.resolve(r.value).then(function (r) { + return { + value: r, + done: n + }; + }); + } + return AsyncFromSyncIterator = function AsyncFromSyncIterator(r) { + this.s = r, this.n = r.next; + }, AsyncFromSyncIterator.prototype = { + s: null, + n: null, + next: function next() { + return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments)); + }, + "return": function _return(r) { + var n = this.s["return"]; + return void 0 === n ? Promise.resolve({ + value: r, + done: !0 + }) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments)); + }, + "throw": function _throw(r) { + var n = this.s["return"]; + return void 0 === n ? Promise.reject(r) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments)); + } + }, new AsyncFromSyncIterator(r); +} +export { _asyncIterator as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js new file mode 100644 index 0000000000000000000000000000000000000000..00f29b1f662d5ae6b494d59d114e8fb785bb7feb --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js @@ -0,0 +1,26 @@ +function asyncGeneratorStep(n, t, e, r, o, a, c) { + try { + var i = n[a](c), + u = i.value; + } catch (n) { + return void e(n); + } + i.done ? t(u) : Promise.resolve(u).then(r, o); +} +function _asyncToGenerator(n) { + return function () { + var t = this, + e = arguments; + return new Promise(function (r, o) { + var a = n.apply(t, e); + function _next(n) { + asyncGeneratorStep(a, r, o, _next, _throw, "next", n); + } + function _throw(n) { + asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); + } + _next(void 0); + }); + }; +} +export { _asyncToGenerator as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/awaitAsyncGenerator.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/awaitAsyncGenerator.js new file mode 100644 index 0000000000000000000000000000000000000000..097c88c98e555b32c195ec7e87dc0ad93dc70871 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/awaitAsyncGenerator.js @@ -0,0 +1,5 @@ +import OverloadYield from "./OverloadYield.js"; +function _awaitAsyncGenerator(e) { + return new OverloadYield(e, 0); +} +export { _awaitAsyncGenerator as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/callSuper.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/callSuper.js new file mode 100644 index 0000000000000000000000000000000000000000..6d17a4ee51bd4a93eb4b4f7f5dff60b2040a8deb --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/callSuper.js @@ -0,0 +1,7 @@ +import getPrototypeOf from "./getPrototypeOf.js"; +import isNativeReflectConstruct from "./isNativeReflectConstruct.js"; +import possibleConstructorReturn from "./possibleConstructorReturn.js"; +function _callSuper(t, o, e) { + return o = getPrototypeOf(o), possibleConstructorReturn(t, isNativeReflectConstruct() ? Reflect.construct(o, e || [], getPrototypeOf(t).constructor) : o.apply(t, e)); +} +export { _callSuper as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/checkInRHS.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/checkInRHS.js new file mode 100644 index 0000000000000000000000000000000000000000..12f59b4cae30ebc369045c6992f61d3835bea28e --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/checkInRHS.js @@ -0,0 +1,6 @@ +import _typeof from "./typeof.js"; +function _checkInRHS(e) { + if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? _typeof(e) : "null")); + return e; +} +export { _checkInRHS as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/checkPrivateRedeclaration.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/checkPrivateRedeclaration.js new file mode 100644 index 0000000000000000000000000000000000000000..e9e6b3b46cf7dca490eb934078e9739a87cb7c1e --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/checkPrivateRedeclaration.js @@ -0,0 +1,4 @@ +function _checkPrivateRedeclaration(e, t) { + if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); +} +export { _checkPrivateRedeclaration as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorDestructureSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorDestructureSet.js new file mode 100644 index 0000000000000000000000000000000000000000..56234195ca486e5953702b13a63ba74dc72d6781 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorDestructureSet.js @@ -0,0 +1,10 @@ +function _classApplyDescriptorDestructureSet(e, t) { + if (t.set) return "__destrObj" in t || (t.__destrObj = { + set value(r) { + t.set.call(e, r); + } + }), t.__destrObj; + if (!t.writable) throw new TypeError("attempted to set read only private field"); + return t; +} +export { _classApplyDescriptorDestructureSet as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorGet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorGet.js new file mode 100644 index 0000000000000000000000000000000000000000..b9259d3e305cfdf92d5c7cf3c769f716990d5264 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorGet.js @@ -0,0 +1,4 @@ +function _classApplyDescriptorGet(e, t) { + return t.get ? t.get.call(e) : t.value; +} +export { _classApplyDescriptorGet as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorSet.js new file mode 100644 index 0000000000000000000000000000000000000000..d9c4fbd2c59c838a6b000f5679632a783038b785 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classApplyDescriptorSet.js @@ -0,0 +1,7 @@ +function _classApplyDescriptorSet(e, t, l) { + if (t.set) t.set.call(e, l);else { + if (!t.writable) throw new TypeError("attempted to set read only private field"); + t.value = l; + } +} +export { _classApplyDescriptorSet as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classCallCheck.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classCallCheck.js new file mode 100644 index 0000000000000000000000000000000000000000..bf97219365660019bba20ef1c79b9765a5db5fb7 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classCallCheck.js @@ -0,0 +1,4 @@ +function _classCallCheck(a, n) { + if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); +} +export { _classCallCheck as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classCheckPrivateStaticAccess.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classCheckPrivateStaticAccess.js new file mode 100644 index 0000000000000000000000000000000000000000..366ed05e4416b71a405e539d9d1f1c69230f431f --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classCheckPrivateStaticAccess.js @@ -0,0 +1,5 @@ +import assertClassBrand from "./assertClassBrand.js"; +function _classCheckPrivateStaticAccess(s, a, r) { + return assertClassBrand(a, s, r); +} +export { _classCheckPrivateStaticAccess as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classCheckPrivateStaticFieldDescriptor.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classCheckPrivateStaticFieldDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..844be91a8f26594ec85fabc80db4e0cea3b1767d --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classCheckPrivateStaticFieldDescriptor.js @@ -0,0 +1,4 @@ +function _classCheckPrivateStaticFieldDescriptor(t, e) { + if (void 0 === t) throw new TypeError("attempted to " + e + " private static field before its declaration"); +} +export { _classCheckPrivateStaticFieldDescriptor as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classExtractFieldDescriptor.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classExtractFieldDescriptor.js new file mode 100644 index 0000000000000000000000000000000000000000..652689d133051829bb67a4b3bd2731e258ad4448 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classExtractFieldDescriptor.js @@ -0,0 +1,5 @@ +import classPrivateFieldGet2 from "./classPrivateFieldGet2.js"; +function _classExtractFieldDescriptor(e, t) { + return classPrivateFieldGet2(t, e); +} +export { _classExtractFieldDescriptor as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classNameTDZError.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classNameTDZError.js new file mode 100644 index 0000000000000000000000000000000000000000..68e76ff74f1368e7d802c025409b0f9350057613 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classNameTDZError.js @@ -0,0 +1,4 @@ +function _classNameTDZError(e) { + throw new ReferenceError('Class "' + e + '" cannot be referenced in computed property keys.'); +} +export { _classNameTDZError as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldDestructureSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldDestructureSet.js new file mode 100644 index 0000000000000000000000000000000000000000..93033663ac156d5d16af3857ccd5d9008932bd16 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldDestructureSet.js @@ -0,0 +1,7 @@ +import classApplyDescriptorDestructureSet from "./classApplyDescriptorDestructureSet.js"; +import classPrivateFieldGet2 from "./classPrivateFieldGet2.js"; +function _classPrivateFieldDestructureSet(e, t) { + var r = classPrivateFieldGet2(t, e); + return classApplyDescriptorDestructureSet(e, r); +} +export { _classPrivateFieldDestructureSet as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldGet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldGet.js new file mode 100644 index 0000000000000000000000000000000000000000..ce7ebcb716e7fcde838baa3fa1734a9d3a962588 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldGet.js @@ -0,0 +1,7 @@ +import classApplyDescriptorGet from "./classApplyDescriptorGet.js"; +import classPrivateFieldGet2 from "./classPrivateFieldGet2.js"; +function _classPrivateFieldGet(e, t) { + var r = classPrivateFieldGet2(t, e); + return classApplyDescriptorGet(e, r); +} +export { _classPrivateFieldGet as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldGet2.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldGet2.js new file mode 100644 index 0000000000000000000000000000000000000000..4aa3da6b5481062ce4003bf4cade19a3c40266a6 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldGet2.js @@ -0,0 +1,5 @@ +import assertClassBrand from "./assertClassBrand.js"; +function _classPrivateFieldGet2(s, a) { + return s.get(assertClassBrand(s, a)); +} +export { _classPrivateFieldGet2 as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldInitSpec.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldInitSpec.js new file mode 100644 index 0000000000000000000000000000000000000000..5dcdbe04a1801a168b55d9242e0f599a60aed79a --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldInitSpec.js @@ -0,0 +1,5 @@ +import checkPrivateRedeclaration from "./checkPrivateRedeclaration.js"; +function _classPrivateFieldInitSpec(e, t, a) { + checkPrivateRedeclaration(e, t), t.set(e, a); +} +export { _classPrivateFieldInitSpec as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldLooseBase.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldLooseBase.js new file mode 100644 index 0000000000000000000000000000000000000000..4bd662ca7f9e1b6ab2833a738839074d8c3fbb5e --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldLooseBase.js @@ -0,0 +1,5 @@ +function _classPrivateFieldBase(e, t) { + if (!{}.hasOwnProperty.call(e, t)) throw new TypeError("attempted to use private field on non-instance"); + return e; +} +export { _classPrivateFieldBase as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldLooseKey.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldLooseKey.js new file mode 100644 index 0000000000000000000000000000000000000000..90d21937c9db2245eee155ac94dc445f810d0ebd --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldLooseKey.js @@ -0,0 +1,5 @@ +var id = 0; +function _classPrivateFieldKey(e) { + return "__private_" + id++ + "_" + e; +} +export { _classPrivateFieldKey as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldSet.js new file mode 100644 index 0000000000000000000000000000000000000000..b5161bdb67f560a0a4c1cda927e05daa16e02c6d --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldSet.js @@ -0,0 +1,7 @@ +import classApplyDescriptorSet from "./classApplyDescriptorSet.js"; +import classPrivateFieldGet2 from "./classPrivateFieldGet2.js"; +function _classPrivateFieldSet(e, t, r) { + var s = classPrivateFieldGet2(t, e); + return classApplyDescriptorSet(e, s, r), r; +} +export { _classPrivateFieldSet as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldSet2.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldSet2.js new file mode 100644 index 0000000000000000000000000000000000000000..337b01a493a38dc5493687e942b1aef3d091c357 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateFieldSet2.js @@ -0,0 +1,5 @@ +import assertClassBrand from "./assertClassBrand.js"; +function _classPrivateFieldSet2(s, a, r) { + return s.set(assertClassBrand(s, a), r), r; +} +export { _classPrivateFieldSet2 as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateGetter.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateGetter.js new file mode 100644 index 0000000000000000000000000000000000000000..ff3e98513d7a57ad9a2acb81abe1b22e5a4b3af4 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateGetter.js @@ -0,0 +1,5 @@ +import assertClassBrand from "./assertClassBrand.js"; +function _classPrivateGetter(s, r, a) { + return a(assertClassBrand(s, r)); +} +export { _classPrivateGetter as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateMethodGet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateMethodGet.js new file mode 100644 index 0000000000000000000000000000000000000000..4832fc6f76d3a8f16711aa47358d8dcdb6f36d3e --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateMethodGet.js @@ -0,0 +1,5 @@ +import assertClassBrand from "./assertClassBrand.js"; +function _classPrivateMethodGet(s, a, r) { + return assertClassBrand(a, s), r; +} +export { _classPrivateMethodGet as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateMethodInitSpec.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateMethodInitSpec.js new file mode 100644 index 0000000000000000000000000000000000000000..61e23e26f3fddefc269594b40ff267f55a98865c --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateMethodInitSpec.js @@ -0,0 +1,5 @@ +import checkPrivateRedeclaration from "./checkPrivateRedeclaration.js"; +function _classPrivateMethodInitSpec(e, a) { + checkPrivateRedeclaration(e, a), a.add(e); +} +export { _classPrivateMethodInitSpec as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateMethodSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateMethodSet.js new file mode 100644 index 0000000000000000000000000000000000000000..d181b5135682cb6eecd10951cfe3fb4f73ebc2b1 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateMethodSet.js @@ -0,0 +1,4 @@ +function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); +} +export { _classPrivateMethodSet as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateSetter.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateSetter.js new file mode 100644 index 0000000000000000000000000000000000000000..9a80d59bc10486af790f23e18b929775114d0c2f --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classPrivateSetter.js @@ -0,0 +1,5 @@ +import assertClassBrand from "./assertClassBrand.js"; +function _classPrivateSetter(s, r, a, t) { + return r(assertClassBrand(s, a), t), t; +} +export { _classPrivateSetter as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldDestructureSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldDestructureSet.js new file mode 100644 index 0000000000000000000000000000000000000000..747e639d596719b6500625126381e049f7174fc6 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldDestructureSet.js @@ -0,0 +1,7 @@ +import classApplyDescriptorDestructureSet from "./classApplyDescriptorDestructureSet.js"; +import assertClassBrand from "./assertClassBrand.js"; +import classCheckPrivateStaticFieldDescriptor from "./classCheckPrivateStaticFieldDescriptor.js"; +function _classStaticPrivateFieldDestructureSet(t, r, s) { + return assertClassBrand(r, t), classCheckPrivateStaticFieldDescriptor(s, "set"), classApplyDescriptorDestructureSet(t, s); +} +export { _classStaticPrivateFieldDestructureSet as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldSpecGet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldSpecGet.js new file mode 100644 index 0000000000000000000000000000000000000000..23684b74935adec2568c901e8075804541db0134 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldSpecGet.js @@ -0,0 +1,7 @@ +import classApplyDescriptorGet from "./classApplyDescriptorGet.js"; +import assertClassBrand from "./assertClassBrand.js"; +import classCheckPrivateStaticFieldDescriptor from "./classCheckPrivateStaticFieldDescriptor.js"; +function _classStaticPrivateFieldSpecGet(t, s, r) { + return assertClassBrand(s, t), classCheckPrivateStaticFieldDescriptor(r, "get"), classApplyDescriptorGet(t, r); +} +export { _classStaticPrivateFieldSpecGet as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldSpecSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldSpecSet.js new file mode 100644 index 0000000000000000000000000000000000000000..3a314682c0dff8a92ce08ca3b22c973cfc9090ad --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classStaticPrivateFieldSpecSet.js @@ -0,0 +1,7 @@ +import classApplyDescriptorSet from "./classApplyDescriptorSet.js"; +import assertClassBrand from "./assertClassBrand.js"; +import classCheckPrivateStaticFieldDescriptor from "./classCheckPrivateStaticFieldDescriptor.js"; +function _classStaticPrivateFieldSpecSet(s, t, r, e) { + return assertClassBrand(t, s), classCheckPrivateStaticFieldDescriptor(r, "set"), classApplyDescriptorSet(s, r, e), e; +} +export { _classStaticPrivateFieldSpecSet as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classStaticPrivateMethodGet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classStaticPrivateMethodGet.js new file mode 100644 index 0000000000000000000000000000000000000000..047b177b0260a19525882ead86b0cb0b9a394c00 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classStaticPrivateMethodGet.js @@ -0,0 +1,5 @@ +import assertClassBrand from "./assertClassBrand.js"; +function _classStaticPrivateMethodGet(s, a, t) { + return assertClassBrand(a, s), t; +} +export { _classStaticPrivateMethodGet as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classStaticPrivateMethodSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classStaticPrivateMethodSet.js new file mode 100644 index 0000000000000000000000000000000000000000..a61ae63ee90b8b9a2c05ccabb666b52392153264 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/classStaticPrivateMethodSet.js @@ -0,0 +1,4 @@ +function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); +} +export { _classStaticPrivateMethodSet as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/construct.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/construct.js new file mode 100644 index 0000000000000000000000000000000000000000..91609ff7861b33f22905933608c209619c317427 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/construct.js @@ -0,0 +1,10 @@ +import isNativeReflectConstruct from "./isNativeReflectConstruct.js"; +import setPrototypeOf from "./setPrototypeOf.js"; +function _construct(t, e, r) { + if (isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments); + var o = [null]; + o.push.apply(o, e); + var p = new (t.bind.apply(t, o))(); + return r && setPrototypeOf(p, r.prototype), p; +} +export { _construct as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/createClass.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/createClass.js new file mode 100644 index 0000000000000000000000000000000000000000..9b178515eb7a72e825e3d4acd4f8f74b8e6438bd --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/createClass.js @@ -0,0 +1,13 @@ +import toPropertyKey from "./toPropertyKey.js"; +function _defineProperties(e, r) { + for (var t = 0; t < r.length; t++) { + var o = r[t]; + o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, toPropertyKey(o.key), o); + } +} +function _createClass(e, r, t) { + return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { + writable: !1 + }), e; +} +export { _createClass as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js new file mode 100644 index 0000000000000000000000000000000000000000..93b97f915113f730424bc88d20a599d6f6da2eb8 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js @@ -0,0 +1,50 @@ +import unsupportedIterableToArray from "./unsupportedIterableToArray.js"; +function _createForOfIteratorHelper(r, e) { + var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; + if (!t) { + if (Array.isArray(r) || (t = unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { + t && (r = t); + var _n = 0, + F = function F() {}; + return { + s: F, + n: function n() { + return _n >= r.length ? { + done: !0 + } : { + done: !1, + value: r[_n++] + }; + }, + e: function e(r) { + throw r; + }, + f: F + }; + } + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + var o, + a = !0, + u = !1; + return { + s: function s() { + t = t.call(r); + }, + n: function n() { + var r = t.next(); + return a = r.done, r; + }, + e: function e(r) { + u = !0, o = r; + }, + f: function f() { + try { + a || null == t["return"] || t["return"](); + } finally { + if (u) throw o; + } + } + }; +} +export { _createForOfIteratorHelper as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelperLoose.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelperLoose.js new file mode 100644 index 0000000000000000000000000000000000000000..3deaae443368fc22d581457c5b05704f7edd0026 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelperLoose.js @@ -0,0 +1,19 @@ +import unsupportedIterableToArray from "./unsupportedIterableToArray.js"; +function _createForOfIteratorHelperLoose(r, e) { + var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; + if (t) return (t = t.call(r)).next.bind(t); + if (Array.isArray(r) || (t = unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { + t && (r = t); + var o = 0; + return function () { + return o >= r.length ? { + done: !0 + } : { + done: !1, + value: r[o++] + }; + }; + } + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} +export { _createForOfIteratorHelperLoose as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/createSuper.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/createSuper.js new file mode 100644 index 0000000000000000000000000000000000000000..dfabf7115e5ae94da2ff457e38291d7637b4a395 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/createSuper.js @@ -0,0 +1,16 @@ +import getPrototypeOf from "./getPrototypeOf.js"; +import isNativeReflectConstruct from "./isNativeReflectConstruct.js"; +import possibleConstructorReturn from "./possibleConstructorReturn.js"; +function _createSuper(t) { + var r = isNativeReflectConstruct(); + return function () { + var e, + o = getPrototypeOf(t); + if (r) { + var s = getPrototypeOf(this).constructor; + e = Reflect.construct(o, arguments, s); + } else e = o.apply(this, arguments); + return possibleConstructorReturn(this, e); + }; +} +export { _createSuper as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/decorate.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/decorate.js new file mode 100644 index 0000000000000000000000000000000000000000..f76b6a6af86a8fbded26059526d6127c7b1970df --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/decorate.js @@ -0,0 +1,250 @@ +import toArray from "./toArray.js"; +import toPropertyKey from "./toPropertyKey.js"; +function _decorate(e, r, t, i) { + var o = _getDecoratorsApi(); + if (i) for (var n = 0; n < i.length; n++) o = i[n](o); + var s = r(function (e) { + o.initializeInstanceElements(e, a.elements); + }, t), + a = o.decorateClass(_coalesceClassElements(s.d.map(_createElementDescriptor)), e); + return o.initializeClassElements(s.F, a.elements), o.runClassFinishers(s.F, a.finishers); +} +function _getDecoratorsApi() { + _getDecoratorsApi = function _getDecoratorsApi() { + return e; + }; + var e = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function initializeInstanceElements(e, r) { + ["method", "field"].forEach(function (t) { + r.forEach(function (r) { + r.kind === t && "own" === r.placement && this.defineClassElement(e, r); + }, this); + }, this); + }, + initializeClassElements: function initializeClassElements(e, r) { + var t = e.prototype; + ["method", "field"].forEach(function (i) { + r.forEach(function (r) { + var o = r.placement; + if (r.kind === i && ("static" === o || "prototype" === o)) { + var n = "static" === o ? e : t; + this.defineClassElement(n, r); + } + }, this); + }, this); + }, + defineClassElement: function defineClassElement(e, r) { + var t = r.descriptor; + if ("field" === r.kind) { + var i = r.initializer; + t = { + enumerable: t.enumerable, + writable: t.writable, + configurable: t.configurable, + value: void 0 === i ? void 0 : i.call(e) + }; + } + Object.defineProperty(e, r.key, t); + }, + decorateClass: function decorateClass(e, r) { + var t = [], + i = [], + o = { + "static": [], + prototype: [], + own: [] + }; + if (e.forEach(function (e) { + this.addElementPlacement(e, o); + }, this), e.forEach(function (e) { + if (!_hasDecorators(e)) return t.push(e); + var r = this.decorateElement(e, o); + t.push(r.element), t.push.apply(t, r.extras), i.push.apply(i, r.finishers); + }, this), !r) return { + elements: t, + finishers: i + }; + var n = this.decorateConstructor(t, r); + return i.push.apply(i, n.finishers), n.finishers = i, n; + }, + addElementPlacement: function addElementPlacement(e, r, t) { + var i = r[e.placement]; + if (!t && -1 !== i.indexOf(e.key)) throw new TypeError("Duplicated element (" + e.key + ")"); + i.push(e.key); + }, + decorateElement: function decorateElement(e, r) { + for (var t = [], i = [], o = e.decorators, n = o.length - 1; n >= 0; n--) { + var s = r[e.placement]; + s.splice(s.indexOf(e.key), 1); + var a = this.fromElementDescriptor(e), + l = this.toElementFinisherExtras((0, o[n])(a) || a); + e = l.element, this.addElementPlacement(e, r), l.finisher && i.push(l.finisher); + var c = l.extras; + if (c) { + for (var p = 0; p < c.length; p++) this.addElementPlacement(c[p], r); + t.push.apply(t, c); + } + } + return { + element: e, + finishers: i, + extras: t + }; + }, + decorateConstructor: function decorateConstructor(e, r) { + for (var t = [], i = r.length - 1; i >= 0; i--) { + var o = this.fromClassDescriptor(e), + n = this.toClassDescriptor((0, r[i])(o) || o); + if (void 0 !== n.finisher && t.push(n.finisher), void 0 !== n.elements) { + e = n.elements; + for (var s = 0; s < e.length - 1; s++) for (var a = s + 1; a < e.length; a++) if (e[s].key === e[a].key && e[s].placement === e[a].placement) throw new TypeError("Duplicated element (" + e[s].key + ")"); + } + } + return { + elements: e, + finishers: t + }; + }, + fromElementDescriptor: function fromElementDescriptor(e) { + var r = { + kind: e.kind, + key: e.key, + placement: e.placement, + descriptor: e.descriptor + }; + return Object.defineProperty(r, Symbol.toStringTag, { + value: "Descriptor", + configurable: !0 + }), "field" === e.kind && (r.initializer = e.initializer), r; + }, + toElementDescriptors: function toElementDescriptors(e) { + if (void 0 !== e) return toArray(e).map(function (e) { + var r = this.toElementDescriptor(e); + return this.disallowProperty(e, "finisher", "An element descriptor"), this.disallowProperty(e, "extras", "An element descriptor"), r; + }, this); + }, + toElementDescriptor: function toElementDescriptor(e) { + var r = e.kind + ""; + if ("method" !== r && "field" !== r) throw new TypeError('An element descriptor\'s .kind property must be either "method" or "field", but a decorator created an element descriptor with .kind "' + r + '"'); + var t = toPropertyKey(e.key), + i = e.placement + ""; + if ("static" !== i && "prototype" !== i && "own" !== i) throw new TypeError('An element descriptor\'s .placement property must be one of "static", "prototype" or "own", but a decorator created an element descriptor with .placement "' + i + '"'); + var o = e.descriptor; + this.disallowProperty(e, "elements", "An element descriptor"); + var n = { + kind: r, + key: t, + placement: i, + descriptor: Object.assign({}, o) + }; + return "field" !== r ? this.disallowProperty(e, "initializer", "A method descriptor") : (this.disallowProperty(o, "get", "The property descriptor of a field descriptor"), this.disallowProperty(o, "set", "The property descriptor of a field descriptor"), this.disallowProperty(o, "value", "The property descriptor of a field descriptor"), n.initializer = e.initializer), n; + }, + toElementFinisherExtras: function toElementFinisherExtras(e) { + return { + element: this.toElementDescriptor(e), + finisher: _optionalCallableProperty(e, "finisher"), + extras: this.toElementDescriptors(e.extras) + }; + }, + fromClassDescriptor: function fromClassDescriptor(e) { + var r = { + kind: "class", + elements: e.map(this.fromElementDescriptor, this) + }; + return Object.defineProperty(r, Symbol.toStringTag, { + value: "Descriptor", + configurable: !0 + }), r; + }, + toClassDescriptor: function toClassDescriptor(e) { + var r = e.kind + ""; + if ("class" !== r) throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator created a class descriptor with .kind "' + r + '"'); + this.disallowProperty(e, "key", "A class descriptor"), this.disallowProperty(e, "placement", "A class descriptor"), this.disallowProperty(e, "descriptor", "A class descriptor"), this.disallowProperty(e, "initializer", "A class descriptor"), this.disallowProperty(e, "extras", "A class descriptor"); + var t = _optionalCallableProperty(e, "finisher"); + return { + elements: this.toElementDescriptors(e.elements), + finisher: t + }; + }, + runClassFinishers: function runClassFinishers(e, r) { + for (var t = 0; t < r.length; t++) { + var i = (0, r[t])(e); + if (void 0 !== i) { + if ("function" != typeof i) throw new TypeError("Finishers must return a constructor."); + e = i; + } + } + return e; + }, + disallowProperty: function disallowProperty(e, r, t) { + if (void 0 !== e[r]) throw new TypeError(t + " can't have a ." + r + " property."); + } + }; + return e; +} +function _createElementDescriptor(e) { + var r, + t = toPropertyKey(e.key); + "method" === e.kind ? r = { + value: e.value, + writable: !0, + configurable: !0, + enumerable: !1 + } : "get" === e.kind ? r = { + get: e.value, + configurable: !0, + enumerable: !1 + } : "set" === e.kind ? r = { + set: e.value, + configurable: !0, + enumerable: !1 + } : "field" === e.kind && (r = { + configurable: !0, + writable: !0, + enumerable: !0 + }); + var i = { + kind: "field" === e.kind ? "field" : "method", + key: t, + placement: e["static"] ? "static" : "field" === e.kind ? "own" : "prototype", + descriptor: r + }; + return e.decorators && (i.decorators = e.decorators), "field" === e.kind && (i.initializer = e.value), i; +} +function _coalesceGetterSetter(e, r) { + void 0 !== e.descriptor.get ? r.descriptor.get = e.descriptor.get : r.descriptor.set = e.descriptor.set; +} +function _coalesceClassElements(e) { + for (var r = [], isSameElement = function isSameElement(e) { + return "method" === e.kind && e.key === o.key && e.placement === o.placement; + }, t = 0; t < e.length; t++) { + var i, + o = e[t]; + if ("method" === o.kind && (i = r.find(isSameElement))) { + if (_isDataDescriptor(o.descriptor) || _isDataDescriptor(i.descriptor)) { + if (_hasDecorators(o) || _hasDecorators(i)) throw new ReferenceError("Duplicated methods (" + o.key + ") can't be decorated."); + i.descriptor = o.descriptor; + } else { + if (_hasDecorators(o)) { + if (_hasDecorators(i)) throw new ReferenceError("Decorators can't be placed on different accessors with for the same property (" + o.key + ")."); + i.decorators = o.decorators; + } + _coalesceGetterSetter(o, i); + } + } else r.push(o); + } + return r; +} +function _hasDecorators(e) { + return e.decorators && e.decorators.length; +} +function _isDataDescriptor(e) { + return void 0 !== e && !(void 0 === e.value && void 0 === e.writable); +} +function _optionalCallableProperty(e, r) { + var t = e[r]; + if (void 0 !== t && "function" != typeof t) throw new TypeError("Expected '" + r + "' to be a function"); + return t; +} +export { _decorate as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/defaults.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/defaults.js new file mode 100644 index 0000000000000000000000000000000000000000..d3041a3d127bd717c4239304d6dd7e23b4e65a9d --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/defaults.js @@ -0,0 +1,9 @@ +function _defaults(e, r) { + for (var t = Object.getOwnPropertyNames(r), o = 0; o < t.length; o++) { + var n = t[o], + a = Object.getOwnPropertyDescriptor(r, n); + a && a.configurable && void 0 === e[n] && Object.defineProperty(e, n, a); + } + return e; +} +export { _defaults as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/defineAccessor.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/defineAccessor.js new file mode 100644 index 0000000000000000000000000000000000000000..a8292deafe53bbc71f70edf2eae4c48c3bca02cf --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/defineAccessor.js @@ -0,0 +1,8 @@ +function _defineAccessor(e, r, n, t) { + var c = { + configurable: !0, + enumerable: !0 + }; + return c[e] = t, Object.defineProperty(r, n, c); +} +export { _defineAccessor as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/defineEnumerableProperties.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/defineEnumerableProperties.js new file mode 100644 index 0000000000000000000000000000000000000000..3d31d9809b453f8c82fa766f9210d4cb0236928b --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/defineEnumerableProperties.js @@ -0,0 +1,12 @@ +function _defineEnumerableProperties(e, r) { + for (var t in r) { + var n = r[t]; + n.configurable = n.enumerable = !0, "value" in n && (n.writable = !0), Object.defineProperty(e, t, n); + } + if (Object.getOwnPropertySymbols) for (var a = Object.getOwnPropertySymbols(r), b = 0; b < a.length; b++) { + var i = a[b]; + (n = r[i]).configurable = n.enumerable = !0, "value" in n && (n.writable = !0), Object.defineProperty(e, i, n); + } + return e; +} +export { _defineEnumerableProperties as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/defineProperty.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/defineProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..05ec32b70e6c58e482cf053aa517f9ff804f14f1 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/defineProperty.js @@ -0,0 +1,10 @@ +import toPropertyKey from "./toPropertyKey.js"; +function _defineProperty(e, r, t) { + return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, { + value: t, + enumerable: !0, + configurable: !0, + writable: !0 + }) : e[r] = t, e; +} +export { _defineProperty as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/dispose.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/dispose.js new file mode 100644 index 0000000000000000000000000000000000000000..a87ab202618d0065982155a64f8b7d1ec956ec97 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/dispose.js @@ -0,0 +1,28 @@ +function dispose_SuppressedError(r, e) { + return "undefined" != typeof SuppressedError ? dispose_SuppressedError = SuppressedError : (dispose_SuppressedError = function dispose_SuppressedError(r, e) { + this.suppressed = e, this.error = r, this.stack = Error().stack; + }, dispose_SuppressedError.prototype = Object.create(Error.prototype, { + constructor: { + value: dispose_SuppressedError, + writable: !0, + configurable: !0 + } + })), new dispose_SuppressedError(r, e); +} +function _dispose(r, e, s) { + function next() { + for (; r.length > 0;) try { + var o = r.pop(), + p = o.d.call(o.v); + if (o.a) return Promise.resolve(p).then(next, err); + } catch (r) { + return err(r); + } + if (s) throw e; + } + function err(r) { + return e = s ? new dispose_SuppressedError(e, r) : r, s = !0, next(); + } + return next(); +} +export { _dispose as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/extends.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/extends.js new file mode 100644 index 0000000000000000000000000000000000000000..53f118ca9dff6fc344bc15046bc6f6239cbb502d --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/extends.js @@ -0,0 +1,10 @@ +function _extends() { + return _extends = Object.assign ? Object.assign.bind() : function (n) { + for (var e = 1; e < arguments.length; e++) { + var t = arguments[e]; + for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); + } + return n; + }, _extends.apply(null, arguments); +} +export { _extends as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/get.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/get.js new file mode 100644 index 0000000000000000000000000000000000000000..8124bc023f1089e78cb860945f1dd553d8efd5ec --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/get.js @@ -0,0 +1,11 @@ +import superPropBase from "./superPropBase.js"; +function _get() { + return _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function (e, t, r) { + var p = superPropBase(e, t); + if (p) { + var n = Object.getOwnPropertyDescriptor(p, t); + return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value; + } + }, _get.apply(null, arguments); +} +export { _get as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js new file mode 100644 index 0000000000000000000000000000000000000000..9073c456bdb39e81cbde7987a0ef80bb5cffe63b --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js @@ -0,0 +1,6 @@ +function _getPrototypeOf(t) { + return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { + return t.__proto__ || Object.getPrototypeOf(t); + }, _getPrototypeOf(t); +} +export { _getPrototypeOf as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/identity.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/identity.js new file mode 100644 index 0000000000000000000000000000000000000000..6b564ac534a4cdb3f90279676c569c099591629f --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/identity.js @@ -0,0 +1,4 @@ +function _identity(t) { + return t; +} +export { _identity as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/importDeferProxy.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/importDeferProxy.js new file mode 100644 index 0000000000000000000000000000000000000000..6d35b526d7585422bfe576896f32622fb5bcdb62 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/importDeferProxy.js @@ -0,0 +1,27 @@ +function _importDeferProxy(e) { + var t = null, + constValue = function constValue(e) { + return function () { + return e; + }; + }, + proxy = function proxy(r) { + return function (n, o, f) { + return null === t && (t = e()), r(t, o, f); + }; + }; + return new Proxy({}, { + defineProperty: constValue(!1), + deleteProperty: constValue(!1), + get: proxy(Reflect.get), + getOwnPropertyDescriptor: proxy(Reflect.getOwnPropertyDescriptor), + getPrototypeOf: constValue(null), + isExtensible: constValue(!1), + has: proxy(Reflect.has), + ownKeys: proxy(Reflect.ownKeys), + preventExtensions: constValue(!0), + set: constValue(!1), + setPrototypeOf: constValue(!1) + }); +} +export { _importDeferProxy as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/inherits.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/inherits.js new file mode 100644 index 0000000000000000000000000000000000000000..78f6e4e33883b54f8c50948598d3864d4a5e68a9 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/inherits.js @@ -0,0 +1,14 @@ +import setPrototypeOf from "./setPrototypeOf.js"; +function _inherits(t, e) { + if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); + t.prototype = Object.create(e && e.prototype, { + constructor: { + value: t, + writable: !0, + configurable: !0 + } + }), Object.defineProperty(t, "prototype", { + writable: !1 + }), e && setPrototypeOf(t, e); +} +export { _inherits as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/inheritsLoose.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/inheritsLoose.js new file mode 100644 index 0000000000000000000000000000000000000000..0bd13306acde8001fd431cd421cd05c9ca2a4372 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/inheritsLoose.js @@ -0,0 +1,5 @@ +import setPrototypeOf from "./setPrototypeOf.js"; +function _inheritsLoose(t, o) { + t.prototype = Object.create(o.prototype), t.prototype.constructor = t, setPrototypeOf(t, o); +} +export { _inheritsLoose as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/initializerDefineProperty.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/initializerDefineProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..68bcc2cd43a4e6a9ab3ea5c5c2f8b4477fce2314 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/initializerDefineProperty.js @@ -0,0 +1,9 @@ +function _initializerDefineProperty(e, i, r, l) { + r && Object.defineProperty(e, i, { + enumerable: r.enumerable, + configurable: r.configurable, + writable: r.writable, + value: r.initializer ? r.initializer.call(l) : void 0 + }); +} +export { _initializerDefineProperty as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/initializerWarningHelper.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/initializerWarningHelper.js new file mode 100644 index 0000000000000000000000000000000000000000..0a658e39ac4d6db2387d7fdc4a22cbd99963d4da --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/initializerWarningHelper.js @@ -0,0 +1,4 @@ +function _initializerWarningHelper(r, e) { + throw Error("Decorating class property failed. Please ensure that transform-class-properties is enabled and runs after the decorators transform."); +} +export { _initializerWarningHelper as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/instanceof.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/instanceof.js new file mode 100644 index 0000000000000000000000000000000000000000..316539ee452149c8bd0b32e5f615b049bd052528 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/instanceof.js @@ -0,0 +1,4 @@ +function _instanceof(n, e) { + return null != e && "undefined" != typeof Symbol && e[Symbol.hasInstance] ? !!e[Symbol.hasInstance](n) : n instanceof e; +} +export { _instanceof as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/interopRequireDefault.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/interopRequireDefault.js new file mode 100644 index 0000000000000000000000000000000000000000..365d248199fc7dcf18649f48add3edbf59de348b --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/interopRequireDefault.js @@ -0,0 +1,6 @@ +function _interopRequireDefault(e) { + return e && e.__esModule ? e : { + "default": e + }; +} +export { _interopRequireDefault as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/interopRequireWildcard.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/interopRequireWildcard.js new file mode 100644 index 0000000000000000000000000000000000000000..ed9ca3187ece159bb74447eb0babbb366b84d78f --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/interopRequireWildcard.js @@ -0,0 +1,22 @@ +import _typeof from "./typeof.js"; +function _interopRequireWildcard(e, t) { + if ("function" == typeof WeakMap) var r = new WeakMap(), + n = new WeakMap(); + return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { + if (!t && e && e.__esModule) return e; + var o, + i, + f = { + __proto__: null, + "default": e + }; + if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; + if (o = t ? n : r) { + if (o.has(e)) return o.get(e); + o.set(e, f); + } + for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); + return f; + })(e, t); +} +export { _interopRequireWildcard as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/isNativeFunction.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/isNativeFunction.js new file mode 100644 index 0000000000000000000000000000000000000000..0cfe276f8df3438490cd2cbcc19385abded1fe6f --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/isNativeFunction.js @@ -0,0 +1,8 @@ +function _isNativeFunction(t) { + try { + return -1 !== Function.toString.call(t).indexOf("[native code]"); + } catch (n) { + return "function" == typeof t; + } +} +export { _isNativeFunction as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js new file mode 100644 index 0000000000000000000000000000000000000000..0eb5e395181a9333b6ff9b980e2f99b69d6468b0 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js @@ -0,0 +1,9 @@ +function _isNativeReflectConstruct() { + try { + var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); + } catch (t) {} + return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { + return !!t; + })(); +} +export { _isNativeReflectConstruct as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/iterableToArray.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/iterableToArray.js new file mode 100644 index 0000000000000000000000000000000000000000..b7de3396ab408b779aa3bde4c3cb9e2925cc6148 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/iterableToArray.js @@ -0,0 +1,4 @@ +function _iterableToArray(r) { + if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); +} +export { _iterableToArray as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js new file mode 100644 index 0000000000000000000000000000000000000000..473f0678192b0dcec901b07f091500d9dbc24687 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js @@ -0,0 +1,28 @@ +function _iterableToArrayLimit(r, l) { + var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; + if (null != t) { + var e, + n, + i, + u, + a = [], + f = !0, + o = !1; + try { + if (i = (t = t.call(r)).next, 0 === l) { + if (Object(t) !== t) return; + f = !1; + } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); + } catch (r) { + o = !0, n = r; + } finally { + try { + if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; + } finally { + if (o) throw n; + } + } + return a; + } +} +export { _iterableToArrayLimit as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/jsx.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/jsx.js new file mode 100644 index 0000000000000000000000000000000000000000..a120e5b6644546060dac58169d25848eb297a26c --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/jsx.js @@ -0,0 +1,22 @@ +var REACT_ELEMENT_TYPE; +function _createRawReactElement(e, r, E, l) { + REACT_ELEMENT_TYPE || (REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol["for"] && Symbol["for"]("react.element") || 60103); + var o = e && e.defaultProps, + n = arguments.length - 3; + if (r || 0 === n || (r = { + children: void 0 + }), 1 === n) r.children = l;else if (n > 1) { + for (var t = Array(n), f = 0; f < n; f++) t[f] = arguments[f + 3]; + r.children = t; + } + if (r && o) for (var i in o) void 0 === r[i] && (r[i] = o[i]);else r || (r = o || {}); + return { + $$typeof: REACT_ELEMENT_TYPE, + type: e, + key: void 0 === E ? null : "" + E, + ref: null, + props: r, + _owner: null + }; +} +export { _createRawReactElement as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/maybeArrayLike.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/maybeArrayLike.js new file mode 100644 index 0000000000000000000000000000000000000000..527c682b3bfe7cc27f4a5e94f900e51f2837cde7 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/maybeArrayLike.js @@ -0,0 +1,9 @@ +import arrayLikeToArray from "./arrayLikeToArray.js"; +function _maybeArrayLike(r, a, e) { + if (a && !Array.isArray(a) && "number" == typeof a.length) { + var y = a.length; + return arrayLikeToArray(a, void 0 !== e && e < y ? e : y); + } + return r(a, e); +} +export { _maybeArrayLike as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/newArrowCheck.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/newArrowCheck.js new file mode 100644 index 0000000000000000000000000000000000000000..5f70e0d791974a5f96f7a2f5841a27444a116da3 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/newArrowCheck.js @@ -0,0 +1,4 @@ +function _newArrowCheck(n, r) { + if (n !== r) throw new TypeError("Cannot instantiate an arrow function"); +} +export { _newArrowCheck as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/nonIterableRest.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/nonIterableRest.js new file mode 100644 index 0000000000000000000000000000000000000000..9050250b17b66776e878af3c200adafd52101a0e --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/nonIterableRest.js @@ -0,0 +1,4 @@ +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} +export { _nonIterableRest as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js new file mode 100644 index 0000000000000000000000000000000000000000..fb03235aea95820f5be217744b244813f4a9358d --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js @@ -0,0 +1,4 @@ +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} +export { _nonIterableSpread as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/nullishReceiverError.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/nullishReceiverError.js new file mode 100644 index 0000000000000000000000000000000000000000..d8c30604635273b3915b8e1208a3ce661658f83d --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/nullishReceiverError.js @@ -0,0 +1,4 @@ +function _nullishReceiverError(r) { + throw new TypeError("Cannot set property of null or undefined."); +} +export { _nullishReceiverError as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/objectDestructuringEmpty.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/objectDestructuringEmpty.js new file mode 100644 index 0000000000000000000000000000000000000000..a92eac8f9570acbc05c3e012895e8c7195fef92d --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/objectDestructuringEmpty.js @@ -0,0 +1,4 @@ +function _objectDestructuringEmpty(t) { + if (null == t) throw new TypeError("Cannot destructure " + t); +} +export { _objectDestructuringEmpty as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/objectSpread.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/objectSpread.js new file mode 100644 index 0000000000000000000000000000000000000000..0f82f069c75a1b06a320908603c9cc3d19054f27 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/objectSpread.js @@ -0,0 +1,14 @@ +import defineProperty from "./defineProperty.js"; +function _objectSpread(e) { + for (var r = 1; r < arguments.length; r++) { + var t = null != arguments[r] ? Object(arguments[r]) : {}, + o = Object.keys(t); + "function" == typeof Object.getOwnPropertySymbols && o.push.apply(o, Object.getOwnPropertySymbols(t).filter(function (e) { + return Object.getOwnPropertyDescriptor(t, e).enumerable; + })), o.forEach(function (r) { + defineProperty(e, r, t[r]); + }); + } + return e; +} +export { _objectSpread as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/objectSpread2.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/objectSpread2.js new file mode 100644 index 0000000000000000000000000000000000000000..0035bc76239911a2bb031cae7f76afb72b46c47d --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/objectSpread2.js @@ -0,0 +1,23 @@ +import defineProperty from "./defineProperty.js"; +function ownKeys(e, r) { + var t = Object.keys(e); + if (Object.getOwnPropertySymbols) { + var o = Object.getOwnPropertySymbols(e); + r && (o = o.filter(function (r) { + return Object.getOwnPropertyDescriptor(e, r).enumerable; + })), t.push.apply(t, o); + } + return t; +} +function _objectSpread2(e) { + for (var r = 1; r < arguments.length; r++) { + var t = null != arguments[r] ? arguments[r] : {}; + r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { + defineProperty(e, r, t[r]); + }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { + Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); + }); + } + return e; +} +export { _objectSpread2 as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js new file mode 100644 index 0000000000000000000000000000000000000000..598fb9ade68452c26c1e8bead1c36ecf7e2550b1 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js @@ -0,0 +1,13 @@ +import objectWithoutPropertiesLoose from "./objectWithoutPropertiesLoose.js"; +function _objectWithoutProperties(e, t) { + if (null == e) return {}; + var o, + r, + i = objectWithoutPropertiesLoose(e, t); + if (Object.getOwnPropertySymbols) { + var n = Object.getOwnPropertySymbols(e); + for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); + } + return i; +} +export { _objectWithoutProperties as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js new file mode 100644 index 0000000000000000000000000000000000000000..90f68f3dddeba4775f4f1c6dad4c6a46de159c79 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js @@ -0,0 +1,10 @@ +function _objectWithoutPropertiesLoose(r, e) { + if (null == r) return {}; + var t = {}; + for (var n in r) if ({}.hasOwnProperty.call(r, n)) { + if (-1 !== e.indexOf(n)) continue; + t[n] = r[n]; + } + return t; +} +export { _objectWithoutPropertiesLoose as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/package.json b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/package.json new file mode 100644 index 0000000000000000000000000000000000000000..aead43de364cd1cc107d5fc3a4ea6fea7d7bd01c --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/package.json @@ -0,0 +1,3 @@ +{ + "type": "module" +} \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js new file mode 100644 index 0000000000000000000000000000000000000000..d84e1e6fc2b75131d35429a0955a7edd3e8dabf7 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js @@ -0,0 +1,8 @@ +import _typeof from "./typeof.js"; +import assertThisInitialized from "./assertThisInitialized.js"; +function _possibleConstructorReturn(t, e) { + if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; + if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); + return assertThisInitialized(t); +} +export { _possibleConstructorReturn as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/readOnlyError.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/readOnlyError.js new file mode 100644 index 0000000000000000000000000000000000000000..fcc3e339cbeb19f73a821b52903b3c71abf2e4d2 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/readOnlyError.js @@ -0,0 +1,4 @@ +function _readOnlyError(r) { + throw new TypeError('"' + r + '" is read-only'); +} +export { _readOnlyError as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regenerator.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regenerator.js new file mode 100644 index 0000000000000000000000000000000000000000..6f2f2a17df26bb7962c9f25450a13622e2a5a84a --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regenerator.js @@ -0,0 +1,89 @@ +import regeneratorDefine from "./regeneratorDefine.js"; +function _regenerator() { + /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ + var e, + t, + r = "function" == typeof Symbol ? Symbol : {}, + n = r.iterator || "@@iterator", + o = r.toStringTag || "@@toStringTag"; + function i(r, n, o, i) { + var c = n && n.prototype instanceof Generator ? n : Generator, + u = Object.create(c.prototype); + return regeneratorDefine(u, "_invoke", function (r, n, o) { + var i, + c, + u, + f = 0, + p = o || [], + y = !1, + G = { + p: 0, + n: 0, + v: e, + a: d, + f: d.bind(e, 4), + d: function d(t, r) { + return i = t, c = 0, u = e, G.n = r, a; + } + }; + function d(r, n) { + for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) { + var o, + i = p[t], + d = G.p, + l = i[2]; + r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0)); + } + if (o || r > 1) return a; + throw y = !0, n; + } + return function (o, p, l) { + if (f > 1) throw TypeError("Generator is already running"); + for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) { + i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u); + try { + if (f = 2, i) { + if (c || (o = "next"), t = i[o]) { + if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object"); + if (!t.done) return t; + u = t.value, c < 2 && (c = 0); + } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1); + i = e; + } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break; + } catch (t) { + i = e, c = 1, u = t; + } finally { + f = 1; + } + } + return { + value: t, + done: y + }; + }; + }(r, o, i), !0), u; + } + var a = {}; + function Generator() {} + function GeneratorFunction() {} + function GeneratorFunctionPrototype() {} + t = Object.getPrototypeOf; + var c = [][n] ? t(t([][n]())) : (regeneratorDefine(t = {}, n, function () { + return this; + }), t), + u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c); + function f(e) { + return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e; + } + return GeneratorFunction.prototype = GeneratorFunctionPrototype, regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), regeneratorDefine(u), regeneratorDefine(u, o, "Generator"), regeneratorDefine(u, n, function () { + return this; + }), regeneratorDefine(u, "toString", function () { + return "[object Generator]"; + }), (_regenerator = function _regenerator() { + return { + w: i, + m: f + }; + })(); +} +export { _regenerator as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorAsync.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorAsync.js new file mode 100644 index 0000000000000000000000000000000000000000..f73d4e65c126bd030570a77169ea133f426266d7 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorAsync.js @@ -0,0 +1,8 @@ +import regeneratorAsyncGen from "./regeneratorAsyncGen.js"; +function _regeneratorAsync(n, e, r, t, o) { + var a = regeneratorAsyncGen(n, e, r, t, o); + return a.next().then(function (n) { + return n.done ? n.value : a.next(); + }); +} +export { _regeneratorAsync as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorAsyncGen.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorAsyncGen.js new file mode 100644 index 0000000000000000000000000000000000000000..1932bcde40dc830e4c6c941cfb52ff88e2896117 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorAsyncGen.js @@ -0,0 +1,6 @@ +import regenerator from "./regenerator.js"; +import regeneratorAsyncIterator from "./regeneratorAsyncIterator.js"; +function _regeneratorAsyncGen(r, e, t, o, n) { + return new regeneratorAsyncIterator(regenerator().w(r, e, t, o), n || Promise); +} +export { _regeneratorAsyncGen as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorAsyncIterator.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorAsyncIterator.js new file mode 100644 index 0000000000000000000000000000000000000000..90d84cc70f5b9e257dafb128ded4b917bb92fcea --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorAsyncIterator.js @@ -0,0 +1,33 @@ +import OverloadYield from "./OverloadYield.js"; +import regeneratorDefine from "./regeneratorDefine.js"; +function AsyncIterator(t, e) { + function n(r, o, i, f) { + try { + var c = t[r](o), + u = c.value; + return u instanceof OverloadYield ? e.resolve(u.v).then(function (t) { + n("next", t, i, f); + }, function (t) { + n("throw", t, i, f); + }) : e.resolve(u).then(function (t) { + c.value = t, i(c); + }, function (t) { + return n("throw", t, i, f); + }); + } catch (t) { + f(t); + } + } + var r; + this.next || (regeneratorDefine(AsyncIterator.prototype), regeneratorDefine(AsyncIterator.prototype, "function" == typeof Symbol && Symbol.asyncIterator || "@asyncIterator", function () { + return this; + })), regeneratorDefine(this, "_invoke", function (t, o, i) { + function f() { + return new e(function (e, r) { + n(t, i, e, r); + }); + } + return r = r ? r.then(f, f) : f(); + }, !0); +} +export { AsyncIterator as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorDefine.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorDefine.js new file mode 100644 index 0000000000000000000000000000000000000000..71404706d25688dd0b08fcdccccb0dbc05285d12 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorDefine.js @@ -0,0 +1,22 @@ +function _regeneratorDefine(e, r, n, t) { + var i = Object.defineProperty; + try { + i({}, "", {}); + } catch (e) { + i = 0; + } + _regeneratorDefine = function regeneratorDefine(e, r, n, t) { + function o(r, n) { + _regeneratorDefine(e, r, function (e) { + return this._invoke(r, n, e); + }); + } + r ? i ? i(e, r, { + value: n, + enumerable: !t, + configurable: !t, + writable: !t + }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2)); + }, _regeneratorDefine(e, r, n, t); +} +export { _regeneratorDefine as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorKeys.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorKeys.js new file mode 100644 index 0000000000000000000000000000000000000000..5d0d48ba8189aaa8f8b7f310b015e3c512a5f15c --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorKeys.js @@ -0,0 +1,10 @@ +function _regeneratorKeys(e) { + var n = Object(e), + r = []; + for (var t in n) r.unshift(t); + return function e() { + for (; r.length;) if ((t = r.pop()) in n) return e.value = t, e.done = !1, e; + return e.done = !0, e; + }; +} +export { _regeneratorKeys as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorRuntime.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorRuntime.js new file mode 100644 index 0000000000000000000000000000000000000000..335018848e8a35b5827e7a6afa154cb95eaa4075 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorRuntime.js @@ -0,0 +1,77 @@ +import OverloadYield from "./OverloadYield.js"; +import regenerator from "./regenerator.js"; +import regeneratorAsync from "./regeneratorAsync.js"; +import regeneratorAsyncGen from "./regeneratorAsyncGen.js"; +import regeneratorAsyncIterator from "./regeneratorAsyncIterator.js"; +import regeneratorKeys from "./regeneratorKeys.js"; +import regeneratorValues from "./regeneratorValues.js"; +function _regeneratorRuntime() { + "use strict"; + + var r = regenerator(), + e = r.m(_regeneratorRuntime), + t = (Object.getPrototypeOf ? Object.getPrototypeOf(e) : e.__proto__).constructor; + function n(r) { + var e = "function" == typeof r && r.constructor; + return !!e && (e === t || "GeneratorFunction" === (e.displayName || e.name)); + } + var o = { + "throw": 1, + "return": 2, + "break": 3, + "continue": 3 + }; + function a(r) { + var e, t; + return function (n) { + e || (e = { + stop: function stop() { + return t(n.a, 2); + }, + "catch": function _catch() { + return n.v; + }, + abrupt: function abrupt(r, e) { + return t(n.a, o[r], e); + }, + delegateYield: function delegateYield(r, o, a) { + return e.resultName = o, t(n.d, regeneratorValues(r), a); + }, + finish: function finish(r) { + return t(n.f, r); + } + }, t = function t(r, _t, o) { + n.p = e.prev, n.n = e.next; + try { + return r(_t, o); + } finally { + e.next = n.n; + } + }), e.resultName && (e[e.resultName] = n.v, e.resultName = void 0), e.sent = n.v, e.next = n.n; + try { + return r.call(this, e); + } finally { + n.p = e.prev, n.n = e.next; + } + }; + } + return (_regeneratorRuntime = function _regeneratorRuntime() { + return { + wrap: function wrap(e, t, n, o) { + return r.w(a(e), t, n, o && o.reverse()); + }, + isGeneratorFunction: n, + mark: r.m, + awrap: function awrap(r, e) { + return new OverloadYield(r, e); + }, + AsyncIterator: regeneratorAsyncIterator, + async: function async(r, e, t, o, u) { + return (n(e) ? regeneratorAsyncGen : regeneratorAsync)(a(r), e, t, o, u); + }, + keys: regeneratorKeys, + values: regeneratorValues + }; + })(); +} +export { _regeneratorRuntime as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorValues.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorValues.js new file mode 100644 index 0000000000000000000000000000000000000000..99968525d9e65807c22c0d5637c32b3e92b374ca --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/regeneratorValues.js @@ -0,0 +1,19 @@ +import _typeof from "./typeof.js"; +function _regeneratorValues(e) { + if (null != e) { + var t = e["function" == typeof Symbol && Symbol.iterator || "@@iterator"], + r = 0; + if (t) return t.call(e); + if ("function" == typeof e.next) return e; + if (!isNaN(e.length)) return { + next: function next() { + return e && r >= e.length && (e = void 0), { + value: e && e[r++], + done: !e + }; + } + }; + } + throw new TypeError(_typeof(e) + " is not iterable"); +} +export { _regeneratorValues as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/set.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/set.js new file mode 100644 index 0000000000000000000000000000000000000000..ed0a80399cd4aa16268483777849aa02f1801df2 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/set.js @@ -0,0 +1,22 @@ +import superPropBase from "./superPropBase.js"; +import defineProperty from "./defineProperty.js"; +function set(e, r, t, o) { + return set = "undefined" != typeof Reflect && Reflect.set ? Reflect.set : function (e, r, t, o) { + var f, + i = superPropBase(e, r); + if (i) { + if ((f = Object.getOwnPropertyDescriptor(i, r)).set) return f.set.call(o, t), !0; + if (!f.writable) return !1; + } + if (f = Object.getOwnPropertyDescriptor(o, r)) { + if (!f.writable) return !1; + f.value = t, Object.defineProperty(o, r, f); + } else defineProperty(o, r, t); + return !0; + }, set(e, r, t, o); +} +function _set(e, r, t, o, f) { + if (!set(e, r, t, o || e) && f) throw new TypeError("failed to set property"); + return t; +} +export { _set as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/setFunctionName.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/setFunctionName.js new file mode 100644 index 0000000000000000000000000000000000000000..82213cea5a90430852e2bb11873da7e0d64ca4e0 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/setFunctionName.js @@ -0,0 +1,12 @@ +import _typeof from "./typeof.js"; +function setFunctionName(e, t, n) { + "symbol" == _typeof(t) && (t = (t = t.description) ? "[" + t + "]" : ""); + try { + Object.defineProperty(e, "name", { + configurable: !0, + value: n ? n + " " + t : t + }); + } catch (e) {} + return e; +} +export { setFunctionName as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js new file mode 100644 index 0000000000000000000000000000000000000000..c30983c961e1b7292b01494c54934f571aa2873d --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js @@ -0,0 +1,6 @@ +function _setPrototypeOf(t, e) { + return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { + return t.__proto__ = e, t; + }, _setPrototypeOf(t, e); +} +export { _setPrototypeOf as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/skipFirstGeneratorNext.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/skipFirstGeneratorNext.js new file mode 100644 index 0000000000000000000000000000000000000000..41d5738cd888608d42a41b9f41e582a451d09a8b --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/skipFirstGeneratorNext.js @@ -0,0 +1,7 @@ +function _skipFirstGeneratorNext(t) { + return function () { + var r = t.apply(this, arguments); + return r.next(), r; + }; +} +export { _skipFirstGeneratorNext as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/slicedToArray.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/slicedToArray.js new file mode 100644 index 0000000000000000000000000000000000000000..c044c2a6ae600b9bccf6440b4d6039ffffb1f5b0 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/slicedToArray.js @@ -0,0 +1,8 @@ +import arrayWithHoles from "./arrayWithHoles.js"; +import iterableToArrayLimit from "./iterableToArrayLimit.js"; +import unsupportedIterableToArray from "./unsupportedIterableToArray.js"; +import nonIterableRest from "./nonIterableRest.js"; +function _slicedToArray(r, e) { + return arrayWithHoles(r) || iterableToArrayLimit(r, e) || unsupportedIterableToArray(r, e) || nonIterableRest(); +} +export { _slicedToArray as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/superPropBase.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/superPropBase.js new file mode 100644 index 0000000000000000000000000000000000000000..a5fa38614da27b53b36f3a6f1a01bc8fba5b5cc7 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/superPropBase.js @@ -0,0 +1,6 @@ +import getPrototypeOf from "./getPrototypeOf.js"; +function _superPropBase(t, o) { + for (; !{}.hasOwnProperty.call(t, o) && null !== (t = getPrototypeOf(t));); + return t; +} +export { _superPropBase as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/superPropGet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/superPropGet.js new file mode 100644 index 0000000000000000000000000000000000000000..b2b60a873239e70a0c237cbbb54621017ade26c6 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/superPropGet.js @@ -0,0 +1,9 @@ +import get from "./get.js"; +import getPrototypeOf from "./getPrototypeOf.js"; +function _superPropGet(t, o, e, r) { + var p = get(getPrototypeOf(1 & r ? t.prototype : t), o, e); + return 2 & r && "function" == typeof p ? function (t) { + return p.apply(e, t); + } : p; +} +export { _superPropGet as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/superPropSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/superPropSet.js new file mode 100644 index 0000000000000000000000000000000000000000..e182f386dbb2b0b230513140ff047bd1f405514a --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/superPropSet.js @@ -0,0 +1,6 @@ +import set from "./set.js"; +import getPrototypeOf from "./getPrototypeOf.js"; +function _superPropSet(t, e, o, r, p, f) { + return set(getPrototypeOf(f ? t.prototype : t), e, o, r, p); +} +export { _superPropSet as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteral.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteral.js new file mode 100644 index 0000000000000000000000000000000000000000..3d842cda00b810484e8d6a6fef525b9cc6a32174 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteral.js @@ -0,0 +1,8 @@ +function _taggedTemplateLiteral(e, t) { + return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, { + raw: { + value: Object.freeze(t) + } + })); +} +export { _taggedTemplateLiteral as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteralLoose.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteralLoose.js new file mode 100644 index 0000000000000000000000000000000000000000..741aeb8514b85966349982b4efc2b9717f59711e --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/taggedTemplateLiteralLoose.js @@ -0,0 +1,4 @@ +function _taggedTemplateLiteralLoose(e, t) { + return t || (t = e.slice(0)), e.raw = t, e; +} +export { _taggedTemplateLiteralLoose as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/tdz.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/tdz.js new file mode 100644 index 0000000000000000000000000000000000000000..58df493f419635f6c72bd612cc0a5480e77d11e9 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/tdz.js @@ -0,0 +1,4 @@ +function _tdzError(e) { + throw new ReferenceError(e + " is not defined - temporal dead zone"); +} +export { _tdzError as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/temporalRef.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/temporalRef.js new file mode 100644 index 0000000000000000000000000000000000000000..8dbf014d0f60772f0b8be86653dd169e4ab5d530 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/temporalRef.js @@ -0,0 +1,6 @@ +import temporalUndefined from "./temporalUndefined.js"; +import tdz from "./tdz.js"; +function _temporalRef(r, e) { + return r === temporalUndefined ? tdz(e) : r; +} +export { _temporalRef as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/temporalUndefined.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/temporalUndefined.js new file mode 100644 index 0000000000000000000000000000000000000000..2ec0b0dab572544e6e72a7999b464a09491920a7 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/temporalUndefined.js @@ -0,0 +1,2 @@ +function _temporalUndefined() {} +export { _temporalUndefined as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/toArray.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/toArray.js new file mode 100644 index 0000000000000000000000000000000000000000..e5f0f52a56917296474aed26de9e216ff08fc64c --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/toArray.js @@ -0,0 +1,8 @@ +import arrayWithHoles from "./arrayWithHoles.js"; +import iterableToArray from "./iterableToArray.js"; +import unsupportedIterableToArray from "./unsupportedIterableToArray.js"; +import nonIterableRest from "./nonIterableRest.js"; +function _toArray(r) { + return arrayWithHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableRest(); +} +export { _toArray as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js new file mode 100644 index 0000000000000000000000000000000000000000..f7338e4d56c003948594f27578bc5cb72f3155ce --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js @@ -0,0 +1,8 @@ +import arrayWithoutHoles from "./arrayWithoutHoles.js"; +import iterableToArray from "./iterableToArray.js"; +import unsupportedIterableToArray from "./unsupportedIterableToArray.js"; +import nonIterableSpread from "./nonIterableSpread.js"; +function _toConsumableArray(r) { + return arrayWithoutHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableSpread(); +} +export { _toConsumableArray as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/toPrimitive.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/toPrimitive.js new file mode 100644 index 0000000000000000000000000000000000000000..9a3de46b53f87ed4154fb754afbe9a746ec466b7 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/toPrimitive.js @@ -0,0 +1,12 @@ +import _typeof from "./typeof.js"; +function toPrimitive(t, r) { + if ("object" != _typeof(t) || !t) return t; + var e = t[Symbol.toPrimitive]; + if (void 0 !== e) { + var i = e.call(t, r || "default"); + if ("object" != _typeof(i)) return i; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return ("string" === r ? String : Number)(t); +} +export { toPrimitive as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/toPropertyKey.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/toPropertyKey.js new file mode 100644 index 0000000000000000000000000000000000000000..b3274d877584beea80ad8e1497582fe223fa37c4 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/toPropertyKey.js @@ -0,0 +1,7 @@ +import _typeof from "./typeof.js"; +import toPrimitive from "./toPrimitive.js"; +function toPropertyKey(t) { + var i = toPrimitive(t, "string"); + return "symbol" == _typeof(i) ? i : i + ""; +} +export { toPropertyKey as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/toSetter.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/toSetter.js new file mode 100644 index 0000000000000000000000000000000000000000..b1dbf7ae4ae24903ee2dadc279faafa8a73de3f2 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/toSetter.js @@ -0,0 +1,10 @@ +function _toSetter(t, e, n) { + e || (e = []); + var r = e.length++; + return Object.defineProperty({}, "_", { + set: function set(o) { + e[r] = o, t.apply(n, e); + } + }); +} +export { _toSetter as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/tsRewriteRelativeImportExtensions.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/tsRewriteRelativeImportExtensions.js new file mode 100644 index 0000000000000000000000000000000000000000..28ffc0b9f41b4cd518f856492f610404a2c44fcd --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/tsRewriteRelativeImportExtensions.js @@ -0,0 +1,6 @@ +function tsRewriteRelativeImportExtensions(t, e) { + return "string" == typeof t && /^\.\.?\//.test(t) ? t.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+)?)\.([cm]?)ts$/i, function (t, s, r, n, o) { + return s ? e ? ".jsx" : ".js" : !r || n && o ? r + n + "." + o.toLowerCase() + "js" : t; + }) : t; +} +export { tsRewriteRelativeImportExtensions as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/typeof.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/typeof.js new file mode 100644 index 0000000000000000000000000000000000000000..5b0bc9b057273a616569d6820e7cdcf71dccb6a2 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/typeof.js @@ -0,0 +1,10 @@ +function _typeof(o) { + "@babel/helpers - typeof"; + + return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { + return typeof o; + } : function (o) { + return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; + }, _typeof(o); +} +export { _typeof as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js new file mode 100644 index 0000000000000000000000000000000000000000..33adc4938e19ffde76e667f7b27213a1ed7e27e0 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js @@ -0,0 +1,9 @@ +import arrayLikeToArray from "./arrayLikeToArray.js"; +function _unsupportedIterableToArray(r, a) { + if (r) { + if ("string" == typeof r) return arrayLikeToArray(r, a); + var t = {}.toString.call(r).slice(8, -1); + return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, a) : void 0; + } +} +export { _unsupportedIterableToArray as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/using.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/using.js new file mode 100644 index 0000000000000000000000000000000000000000..9bda17b5573b6eae269db58c0a0db16a0aa7bd87 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/using.js @@ -0,0 +1,12 @@ +function _using(o, n, e) { + if (null == n) return n; + if (Object(n) !== n) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined."); + if (e) var r = n[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")]; + if (null == r && (r = n[Symbol.dispose || Symbol["for"]("Symbol.dispose")]), "function" != typeof r) throw new TypeError("Property [Symbol.dispose] is not a function."); + return o.push({ + v: n, + d: r, + a: e + }), n; +} +export { _using as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/usingCtx.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/usingCtx.js new file mode 100644 index 0000000000000000000000000000000000000000..1464379f78de2f90103d0d9e871e3a11406f08d5 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/usingCtx.js @@ -0,0 +1,59 @@ +function _usingCtx() { + var r = "function" == typeof SuppressedError ? SuppressedError : function (r, e) { + var n = Error(); + return n.name = "SuppressedError", n.error = r, n.suppressed = e, n; + }, + e = {}, + n = []; + function using(r, e) { + if (null != e) { + if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined."); + if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")]; + if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o; + if ("function" != typeof o) throw new TypeError("Object is not disposable."); + t && (o = function o() { + try { + t.call(e); + } catch (r) { + return Promise.reject(r); + } + }), n.push({ + v: e, + d: o, + a: r + }); + } else r && n.push({ + d: e, + a: r + }); + return e; + } + return { + e: e, + u: using.bind(null, !1), + a: using.bind(null, !0), + d: function d() { + var o, + t = this.e, + s = 0; + function next() { + for (; o = n.pop();) try { + if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next); + if (o.d) { + var r = o.d.call(o.v); + if (o.a) return s |= 2, Promise.resolve(r).then(next, err); + } else s |= 1; + } catch (r) { + return err(r); + } + if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve(); + if (t !== e) throw t; + } + function err(n) { + return t = t !== e ? new r(n, t) : n, next(); + } + return next(); + } + }; +} +export { _usingCtx as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/wrapAsyncGenerator.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/wrapAsyncGenerator.js new file mode 100644 index 0000000000000000000000000000000000000000..ffeea5d9cea3719eb1d0566d93fa9a3df2b29d3b --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/wrapAsyncGenerator.js @@ -0,0 +1,69 @@ +import OverloadYield from "./OverloadYield.js"; +function _wrapAsyncGenerator(e) { + return function () { + return new AsyncGenerator(e.apply(this, arguments)); + }; +} +function AsyncGenerator(e) { + var r, t; + function resume(r, t) { + try { + var n = e[r](t), + o = n.value, + u = o instanceof OverloadYield; + Promise.resolve(u ? o.v : o).then(function (t) { + if (u) { + var i = "return" === r ? "return" : "next"; + if (!o.k || t.done) return resume(i, t); + t = e[i](t).value; + } + settle(n.done ? "return" : "normal", t); + }, function (e) { + resume("throw", e); + }); + } catch (e) { + settle("throw", e); + } + } + function settle(e, n) { + switch (e) { + case "return": + r.resolve({ + value: n, + done: !0 + }); + break; + case "throw": + r.reject(n); + break; + default: + r.resolve({ + value: n, + done: !1 + }); + } + (r = r.next) ? resume(r.key, r.arg) : t = null; + } + this._invoke = function (e, n) { + return new Promise(function (o, u) { + var i = { + key: e, + arg: n, + resolve: o, + reject: u, + next: null + }; + t ? t = t.next = i : (r = t = i, resume(e, n)); + }); + }, "function" != typeof e["return"] && (this["return"] = void 0); +} +AsyncGenerator.prototype["function" == typeof Symbol && Symbol.asyncIterator || "@@asyncIterator"] = function () { + return this; +}, AsyncGenerator.prototype.next = function (e) { + return this._invoke("next", e); +}, AsyncGenerator.prototype["throw"] = function (e) { + return this._invoke("throw", e); +}, AsyncGenerator.prototype["return"] = function (e) { + return this._invoke("return", e); +}; +export { _wrapAsyncGenerator as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/wrapNativeSuper.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/wrapNativeSuper.js new file mode 100644 index 0000000000000000000000000000000000000000..15bf78f538fd2bd4121db483cb62accd76b058ba --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/wrapNativeSuper.js @@ -0,0 +1,27 @@ +import getPrototypeOf from "./getPrototypeOf.js"; +import setPrototypeOf from "./setPrototypeOf.js"; +import isNativeFunction from "./isNativeFunction.js"; +import construct from "./construct.js"; +function _wrapNativeSuper(t) { + var r = "function" == typeof Map ? new Map() : void 0; + return _wrapNativeSuper = function _wrapNativeSuper(t) { + if (null === t || !isNativeFunction(t)) return t; + if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function"); + if (void 0 !== r) { + if (r.has(t)) return r.get(t); + r.set(t, Wrapper); + } + function Wrapper() { + return construct(t, arguments, getPrototypeOf(this).constructor); + } + return Wrapper.prototype = Object.create(t.prototype, { + constructor: { + value: Wrapper, + enumerable: !1, + writable: !0, + configurable: !0 + } + }), setPrototypeOf(Wrapper, t); + }, _wrapNativeSuper(t); +} +export { _wrapNativeSuper as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/wrapRegExp.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/wrapRegExp.js new file mode 100644 index 0000000000000000000000000000000000000000..c455faa408c56eee0f316926371354b546dca94d --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/wrapRegExp.js @@ -0,0 +1,52 @@ +import _typeof from "./typeof.js"; +import setPrototypeOf from "./setPrototypeOf.js"; +import inherits from "./inherits.js"; +function _wrapRegExp() { + _wrapRegExp = function _wrapRegExp(e, r) { + return new BabelRegExp(e, void 0, r); + }; + var e = RegExp.prototype, + r = new WeakMap(); + function BabelRegExp(e, t, p) { + var o = RegExp(e, t); + return r.set(o, p || r.get(e)), setPrototypeOf(o, BabelRegExp.prototype); + } + function buildGroups(e, t) { + var p = r.get(t); + return Object.keys(p).reduce(function (r, t) { + var o = p[t]; + if ("number" == typeof o) r[t] = e[o];else { + for (var i = 0; void 0 === e[o[i]] && i + 1 < o.length;) i++; + r[t] = e[o[i]]; + } + return r; + }, Object.create(null)); + } + return inherits(BabelRegExp, RegExp), BabelRegExp.prototype.exec = function (r) { + var t = e.exec.call(this, r); + if (t) { + t.groups = buildGroups(t, this); + var p = t.indices; + p && (p.groups = buildGroups(p, this)); + } + return t; + }, BabelRegExp.prototype[Symbol.replace] = function (t, p) { + if ("string" == typeof p) { + var o = r.get(this); + return e[Symbol.replace].call(this, t, p.replace(/\$<([^>]+)(>|$)/g, function (e, r, t) { + if ("" === t) return e; + var p = o[r]; + return Array.isArray(p) ? "$" + p.join("$") : "number" == typeof p ? "$" + p : ""; + })); + } + if ("function" == typeof p) { + var i = this; + return e[Symbol.replace].call(this, t, function () { + var e = arguments; + return "object" != _typeof(e[e.length - 1]) && (e = [].slice.call(e)).push(buildGroups(e, i)), p.apply(this, e); + }); + } + return e[Symbol.replace].call(this, t, p); + }, _wrapRegExp.apply(this, arguments); +} +export { _wrapRegExp as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/writeOnlyError.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/writeOnlyError.js new file mode 100644 index 0000000000000000000000000000000000000000..250c2869f89a0d4d9d35b14895109876f86aac4e --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/esm/writeOnlyError.js @@ -0,0 +1,4 @@ +function _writeOnlyError(r) { + throw new TypeError('"' + r + '" is write-only'); +} +export { _writeOnlyError as default }; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/extends.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/extends.js new file mode 100644 index 0000000000000000000000000000000000000000..eee4a1f438f4d8cdc3fee8d8d17fdb4652cbba15 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/extends.js @@ -0,0 +1,10 @@ +function _extends() { + return module.exports = _extends = Object.assign ? Object.assign.bind() : function (n) { + for (var e = 1; e < arguments.length; e++) { + var t = arguments[e]; + for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); + } + return n; + }, module.exports.__esModule = true, module.exports["default"] = module.exports, _extends.apply(null, arguments); +} +module.exports = _extends, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/get.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/get.js new file mode 100644 index 0000000000000000000000000000000000000000..15428ded5087858c0c2ab636d2ad961a7c063ff3 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/get.js @@ -0,0 +1,11 @@ +var superPropBase = require("./superPropBase.js"); +function _get() { + return module.exports = _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function (e, t, r) { + var p = superPropBase(e, t); + if (p) { + var n = Object.getOwnPropertyDescriptor(p, t); + return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value; + } + }, module.exports.__esModule = true, module.exports["default"] = module.exports, _get.apply(null, arguments); +} +module.exports = _get, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/getPrototypeOf.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/getPrototypeOf.js new file mode 100644 index 0000000000000000000000000000000000000000..90707481a906f33927c5394a5159bdb159fce09f --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/getPrototypeOf.js @@ -0,0 +1,6 @@ +function _getPrototypeOf(t) { + return module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { + return t.__proto__ || Object.getPrototypeOf(t); + }, module.exports.__esModule = true, module.exports["default"] = module.exports, _getPrototypeOf(t); +} +module.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/identity.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/identity.js new file mode 100644 index 0000000000000000000000000000000000000000..54de5b5b81d543d9768a8bca343bfa996cb26176 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/identity.js @@ -0,0 +1,4 @@ +function _identity(t) { + return t; +} +module.exports = _identity, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/importDeferProxy.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/importDeferProxy.js new file mode 100644 index 0000000000000000000000000000000000000000..cffaae65f25c821671f2cc6f50a3cb89ce391b29 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/importDeferProxy.js @@ -0,0 +1,27 @@ +function _importDeferProxy(e) { + var t = null, + constValue = function constValue(e) { + return function () { + return e; + }; + }, + proxy = function proxy(r) { + return function (n, o, f) { + return null === t && (t = e()), r(t, o, f); + }; + }; + return new Proxy({}, { + defineProperty: constValue(!1), + deleteProperty: constValue(!1), + get: proxy(Reflect.get), + getOwnPropertyDescriptor: proxy(Reflect.getOwnPropertyDescriptor), + getPrototypeOf: constValue(null), + isExtensible: constValue(!1), + has: proxy(Reflect.has), + ownKeys: proxy(Reflect.ownKeys), + preventExtensions: constValue(!0), + set: constValue(!1), + setPrototypeOf: constValue(!1) + }); +} +module.exports = _importDeferProxy, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/inherits.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/inherits.js new file mode 100644 index 0000000000000000000000000000000000000000..715a78ef5cb1366455fbbdbe15c02a317ed29ee8 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/inherits.js @@ -0,0 +1,14 @@ +var setPrototypeOf = require("./setPrototypeOf.js"); +function _inherits(t, e) { + if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); + t.prototype = Object.create(e && e.prototype, { + constructor: { + value: t, + writable: !0, + configurable: !0 + } + }), Object.defineProperty(t, "prototype", { + writable: !1 + }), e && setPrototypeOf(t, e); +} +module.exports = _inherits, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/inheritsLoose.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/inheritsLoose.js new file mode 100644 index 0000000000000000000000000000000000000000..a27baf01709fcaf20ac9ff926af0fa0b7b928da3 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/inheritsLoose.js @@ -0,0 +1,5 @@ +var setPrototypeOf = require("./setPrototypeOf.js"); +function _inheritsLoose(t, o) { + t.prototype = Object.create(o.prototype), t.prototype.constructor = t, setPrototypeOf(t, o); +} +module.exports = _inheritsLoose, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/initializerDefineProperty.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/initializerDefineProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..f9fa31730028fd24e7a89a86f4eb4c5102a4f798 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/initializerDefineProperty.js @@ -0,0 +1,9 @@ +function _initializerDefineProperty(e, i, r, l) { + r && Object.defineProperty(e, i, { + enumerable: r.enumerable, + configurable: r.configurable, + writable: r.writable, + value: r.initializer ? r.initializer.call(l) : void 0 + }); +} +module.exports = _initializerDefineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/initializerWarningHelper.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/initializerWarningHelper.js new file mode 100644 index 0000000000000000000000000000000000000000..e14ce59a05dba489202c9bc7bcec289de29d7ab2 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/initializerWarningHelper.js @@ -0,0 +1,4 @@ +function _initializerWarningHelper(r, e) { + throw Error("Decorating class property failed. Please ensure that transform-class-properties is enabled and runs after the decorators transform."); +} +module.exports = _initializerWarningHelper, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/instanceof.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/instanceof.js new file mode 100644 index 0000000000000000000000000000000000000000..9952301dc17c5b41188c7dbe534f90ad6017d512 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/instanceof.js @@ -0,0 +1,4 @@ +function _instanceof(n, e) { + return null != e && "undefined" != typeof Symbol && e[Symbol.hasInstance] ? !!e[Symbol.hasInstance](n) : n instanceof e; +} +module.exports = _instanceof, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/interopRequireDefault.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/interopRequireDefault.js new file mode 100644 index 0000000000000000000000000000000000000000..69447158f687f3a6995316a66d5ca7d17aa0f100 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/interopRequireDefault.js @@ -0,0 +1,6 @@ +function _interopRequireDefault(e) { + return e && e.__esModule ? e : { + "default": e + }; +} +module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/interopRequireWildcard.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/interopRequireWildcard.js new file mode 100644 index 0000000000000000000000000000000000000000..d5f10543f025ddc210c29ce728514e70220b4938 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/interopRequireWildcard.js @@ -0,0 +1,22 @@ +var _typeof = require("./typeof.js")["default"]; +function _interopRequireWildcard(e, t) { + if ("function" == typeof WeakMap) var r = new WeakMap(), + n = new WeakMap(); + return (module.exports = _interopRequireWildcard = function _interopRequireWildcard(e, t) { + if (!t && e && e.__esModule) return e; + var o, + i, + f = { + __proto__: null, + "default": e + }; + if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; + if (o = t ? n : r) { + if (o.has(e)) return o.get(e); + o.set(e, f); + } + for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); + return f; + }, module.exports.__esModule = true, module.exports["default"] = module.exports)(e, t); +} +module.exports = _interopRequireWildcard, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/isNativeFunction.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/isNativeFunction.js new file mode 100644 index 0000000000000000000000000000000000000000..f0eb49e3fdf38b8ddbacc127efe7a39e1d2b0844 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/isNativeFunction.js @@ -0,0 +1,8 @@ +function _isNativeFunction(t) { + try { + return -1 !== Function.toString.call(t).indexOf("[native code]"); + } catch (n) { + return "function" == typeof t; + } +} +module.exports = _isNativeFunction, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js new file mode 100644 index 0000000000000000000000000000000000000000..b677e1076382e0cb07e18348b90d8d0b3292394f --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js @@ -0,0 +1,9 @@ +function _isNativeReflectConstruct() { + try { + var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); + } catch (t) {} + return (module.exports = _isNativeReflectConstruct = function _isNativeReflectConstruct() { + return !!t; + }, module.exports.__esModule = true, module.exports["default"] = module.exports)(); +} +module.exports = _isNativeReflectConstruct, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/iterableToArray.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/iterableToArray.js new file mode 100644 index 0000000000000000000000000000000000000000..c839a32164b6e28580bf4fa908f6c780b7fdc3ee --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/iterableToArray.js @@ -0,0 +1,4 @@ +function _iterableToArray(r) { + if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); +} +module.exports = _iterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/iterableToArrayLimit.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/iterableToArrayLimit.js new file mode 100644 index 0000000000000000000000000000000000000000..2671778bfb27059c18af95497064c094f2183ba8 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/iterableToArrayLimit.js @@ -0,0 +1,28 @@ +function _iterableToArrayLimit(r, l) { + var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; + if (null != t) { + var e, + n, + i, + u, + a = [], + f = !0, + o = !1; + try { + if (i = (t = t.call(r)).next, 0 === l) { + if (Object(t) !== t) return; + f = !1; + } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); + } catch (r) { + o = !0, n = r; + } finally { + try { + if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; + } finally { + if (o) throw n; + } + } + return a; + } +} +module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/jsx.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/jsx.js new file mode 100644 index 0000000000000000000000000000000000000000..3415eead6dfb7fe6c3c8d87add5c8fa16e62f98d --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/jsx.js @@ -0,0 +1,22 @@ +var REACT_ELEMENT_TYPE; +function _createRawReactElement(e, r, E, l) { + REACT_ELEMENT_TYPE || (REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol["for"] && Symbol["for"]("react.element") || 60103); + var o = e && e.defaultProps, + n = arguments.length - 3; + if (r || 0 === n || (r = { + children: void 0 + }), 1 === n) r.children = l;else if (n > 1) { + for (var t = Array(n), f = 0; f < n; f++) t[f] = arguments[f + 3]; + r.children = t; + } + if (r && o) for (var i in o) void 0 === r[i] && (r[i] = o[i]);else r || (r = o || {}); + return { + $$typeof: REACT_ELEMENT_TYPE, + type: e, + key: void 0 === E ? null : "" + E, + ref: null, + props: r, + _owner: null + }; +} +module.exports = _createRawReactElement, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/maybeArrayLike.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/maybeArrayLike.js new file mode 100644 index 0000000000000000000000000000000000000000..9873cc76bfb7dea05c5fcc28594529644adeeb78 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/maybeArrayLike.js @@ -0,0 +1,9 @@ +var arrayLikeToArray = require("./arrayLikeToArray.js"); +function _maybeArrayLike(r, a, e) { + if (a && !Array.isArray(a) && "number" == typeof a.length) { + var y = a.length; + return arrayLikeToArray(a, void 0 !== e && e < y ? e : y); + } + return r(a, e); +} +module.exports = _maybeArrayLike, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/newArrowCheck.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/newArrowCheck.js new file mode 100644 index 0000000000000000000000000000000000000000..8e74d99161d486e3511e7e758b6ab359baadb4f1 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/newArrowCheck.js @@ -0,0 +1,4 @@ +function _newArrowCheck(n, r) { + if (n !== r) throw new TypeError("Cannot instantiate an arrow function"); +} +module.exports = _newArrowCheck, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/nonIterableRest.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/nonIterableRest.js new file mode 100644 index 0000000000000000000000000000000000000000..95265ba32fd124ca4a999b99c16f743e0ff1ef94 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/nonIterableRest.js @@ -0,0 +1,4 @@ +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} +module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/nonIterableSpread.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/nonIterableSpread.js new file mode 100644 index 0000000000000000000000000000000000000000..3fcf23f04315e39bf8d1aabff0284a7b7f20e287 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/nonIterableSpread.js @@ -0,0 +1,4 @@ +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} +module.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/nullishReceiverError.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/nullishReceiverError.js new file mode 100644 index 0000000000000000000000000000000000000000..970e02319032d5c6d9aa1ec15fba5c7a6c957b8f --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/nullishReceiverError.js @@ -0,0 +1,4 @@ +function _nullishReceiverError(r) { + throw new TypeError("Cannot set property of null or undefined."); +} +module.exports = _nullishReceiverError, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/objectDestructuringEmpty.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/objectDestructuringEmpty.js new file mode 100644 index 0000000000000000000000000000000000000000..9f62a1b0525c41f1d80b343ea3861e48c8ce2b92 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/objectDestructuringEmpty.js @@ -0,0 +1,4 @@ +function _objectDestructuringEmpty(t) { + if (null == t) throw new TypeError("Cannot destructure " + t); +} +module.exports = _objectDestructuringEmpty, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/objectSpread.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/objectSpread.js new file mode 100644 index 0000000000000000000000000000000000000000..a367643812c64fc4fa8b5be971323b0447aaf951 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/objectSpread.js @@ -0,0 +1,14 @@ +var defineProperty = require("./defineProperty.js"); +function _objectSpread(e) { + for (var r = 1; r < arguments.length; r++) { + var t = null != arguments[r] ? Object(arguments[r]) : {}, + o = Object.keys(t); + "function" == typeof Object.getOwnPropertySymbols && o.push.apply(o, Object.getOwnPropertySymbols(t).filter(function (e) { + return Object.getOwnPropertyDescriptor(t, e).enumerable; + })), o.forEach(function (r) { + defineProperty(e, r, t[r]); + }); + } + return e; +} +module.exports = _objectSpread, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/objectSpread2.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/objectSpread2.js new file mode 100644 index 0000000000000000000000000000000000000000..4f3b9fa020acbed2e10d2c32e2566991c00ba47b --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/objectSpread2.js @@ -0,0 +1,23 @@ +var defineProperty = require("./defineProperty.js"); +function ownKeys(e, r) { + var t = Object.keys(e); + if (Object.getOwnPropertySymbols) { + var o = Object.getOwnPropertySymbols(e); + r && (o = o.filter(function (r) { + return Object.getOwnPropertyDescriptor(e, r).enumerable; + })), t.push.apply(t, o); + } + return t; +} +function _objectSpread2(e) { + for (var r = 1; r < arguments.length; r++) { + var t = null != arguments[r] ? arguments[r] : {}; + r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { + defineProperty(e, r, t[r]); + }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { + Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); + }); + } + return e; +} +module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/objectWithoutProperties.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/objectWithoutProperties.js new file mode 100644 index 0000000000000000000000000000000000000000..3a40f9e4e6d1074ec0a2572fcc60fb66f2642156 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/objectWithoutProperties.js @@ -0,0 +1,13 @@ +var objectWithoutPropertiesLoose = require("./objectWithoutPropertiesLoose.js"); +function _objectWithoutProperties(e, t) { + if (null == e) return {}; + var o, + r, + i = objectWithoutPropertiesLoose(e, t); + if (Object.getOwnPropertySymbols) { + var n = Object.getOwnPropertySymbols(e); + for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); + } + return i; +} +module.exports = _objectWithoutProperties, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js new file mode 100644 index 0000000000000000000000000000000000000000..c243acdff0e8923402ea9a0069e03776c7162235 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js @@ -0,0 +1,10 @@ +function _objectWithoutPropertiesLoose(r, e) { + if (null == r) return {}; + var t = {}; + for (var n in r) if ({}.hasOwnProperty.call(r, n)) { + if (-1 !== e.indexOf(n)) continue; + t[n] = r[n]; + } + return t; +} +module.exports = _objectWithoutPropertiesLoose, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js new file mode 100644 index 0000000000000000000000000000000000000000..06e6e6d865d50b00dde04a172f2bd2bcaa2aa044 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/possibleConstructorReturn.js @@ -0,0 +1,8 @@ +var _typeof = require("./typeof.js")["default"]; +var assertThisInitialized = require("./assertThisInitialized.js"); +function _possibleConstructorReturn(t, e) { + if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; + if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); + return assertThisInitialized(t); +} +module.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/readOnlyError.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/readOnlyError.js new file mode 100644 index 0000000000000000000000000000000000000000..1bf3e0929f916e4c05e4009150ffedf84329447d --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/readOnlyError.js @@ -0,0 +1,4 @@ +function _readOnlyError(r) { + throw new TypeError('"' + r + '" is read-only'); +} +module.exports = _readOnlyError, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regenerator.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regenerator.js new file mode 100644 index 0000000000000000000000000000000000000000..0cf8710aaee4ef16ed8105bd24167f443d85adb1 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regenerator.js @@ -0,0 +1,89 @@ +var regeneratorDefine = require("./regeneratorDefine.js"); +function _regenerator() { + /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ + var e, + t, + r = "function" == typeof Symbol ? Symbol : {}, + n = r.iterator || "@@iterator", + o = r.toStringTag || "@@toStringTag"; + function i(r, n, o, i) { + var c = n && n.prototype instanceof Generator ? n : Generator, + u = Object.create(c.prototype); + return regeneratorDefine(u, "_invoke", function (r, n, o) { + var i, + c, + u, + f = 0, + p = o || [], + y = !1, + G = { + p: 0, + n: 0, + v: e, + a: d, + f: d.bind(e, 4), + d: function d(t, r) { + return i = t, c = 0, u = e, G.n = r, a; + } + }; + function d(r, n) { + for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) { + var o, + i = p[t], + d = G.p, + l = i[2]; + r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0)); + } + if (o || r > 1) return a; + throw y = !0, n; + } + return function (o, p, l) { + if (f > 1) throw TypeError("Generator is already running"); + for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) { + i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u); + try { + if (f = 2, i) { + if (c || (o = "next"), t = i[o]) { + if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object"); + if (!t.done) return t; + u = t.value, c < 2 && (c = 0); + } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1); + i = e; + } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break; + } catch (t) { + i = e, c = 1, u = t; + } finally { + f = 1; + } + } + return { + value: t, + done: y + }; + }; + }(r, o, i), !0), u; + } + var a = {}; + function Generator() {} + function GeneratorFunction() {} + function GeneratorFunctionPrototype() {} + t = Object.getPrototypeOf; + var c = [][n] ? t(t([][n]())) : (regeneratorDefine(t = {}, n, function () { + return this; + }), t), + u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c); + function f(e) { + return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e; + } + return GeneratorFunction.prototype = GeneratorFunctionPrototype, regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), regeneratorDefine(u), regeneratorDefine(u, o, "Generator"), regeneratorDefine(u, n, function () { + return this; + }), regeneratorDefine(u, "toString", function () { + return "[object Generator]"; + }), (module.exports = _regenerator = function _regenerator() { + return { + w: i, + m: f + }; + }, module.exports.__esModule = true, module.exports["default"] = module.exports)(); +} +module.exports = _regenerator, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorAsync.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorAsync.js new file mode 100644 index 0000000000000000000000000000000000000000..d1e4c3f99ebcb3c46c389782e6c826b56688d04a --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorAsync.js @@ -0,0 +1,8 @@ +var regeneratorAsyncGen = require("./regeneratorAsyncGen.js"); +function _regeneratorAsync(n, e, r, t, o) { + var a = regeneratorAsyncGen(n, e, r, t, o); + return a.next().then(function (n) { + return n.done ? n.value : a.next(); + }); +} +module.exports = _regeneratorAsync, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorAsyncGen.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorAsyncGen.js new file mode 100644 index 0000000000000000000000000000000000000000..f0212e324386262d0d8be733705cbdbb9e00252e --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorAsyncGen.js @@ -0,0 +1,6 @@ +var regenerator = require("./regenerator.js"); +var regeneratorAsyncIterator = require("./regeneratorAsyncIterator.js"); +function _regeneratorAsyncGen(r, e, t, o, n) { + return new regeneratorAsyncIterator(regenerator().w(r, e, t, o), n || Promise); +} +module.exports = _regeneratorAsyncGen, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorAsyncIterator.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorAsyncIterator.js new file mode 100644 index 0000000000000000000000000000000000000000..afcb0601a29ba72f02f6c39bf9c8f984c3a408a0 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorAsyncIterator.js @@ -0,0 +1,33 @@ +var OverloadYield = require("./OverloadYield.js"); +var regeneratorDefine = require("./regeneratorDefine.js"); +function AsyncIterator(t, e) { + function n(r, o, i, f) { + try { + var c = t[r](o), + u = c.value; + return u instanceof OverloadYield ? e.resolve(u.v).then(function (t) { + n("next", t, i, f); + }, function (t) { + n("throw", t, i, f); + }) : e.resolve(u).then(function (t) { + c.value = t, i(c); + }, function (t) { + return n("throw", t, i, f); + }); + } catch (t) { + f(t); + } + } + var r; + this.next || (regeneratorDefine(AsyncIterator.prototype), regeneratorDefine(AsyncIterator.prototype, "function" == typeof Symbol && Symbol.asyncIterator || "@asyncIterator", function () { + return this; + })), regeneratorDefine(this, "_invoke", function (t, o, i) { + function f() { + return new e(function (e, r) { + n(t, i, e, r); + }); + } + return r = r ? r.then(f, f) : f(); + }, !0); +} +module.exports = AsyncIterator, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorDefine.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorDefine.js new file mode 100644 index 0000000000000000000000000000000000000000..8d7ffe09973f8e32cbd5d34852ac020a5fd2f0a8 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorDefine.js @@ -0,0 +1,22 @@ +function _regeneratorDefine(e, r, n, t) { + var i = Object.defineProperty; + try { + i({}, "", {}); + } catch (e) { + i = 0; + } + module.exports = _regeneratorDefine = function regeneratorDefine(e, r, n, t) { + function o(r, n) { + _regeneratorDefine(e, r, function (e) { + return this._invoke(r, n, e); + }); + } + r ? i ? i(e, r, { + value: n, + enumerable: !t, + configurable: !t, + writable: !t + }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2)); + }, module.exports.__esModule = true, module.exports["default"] = module.exports, _regeneratorDefine(e, r, n, t); +} +module.exports = _regeneratorDefine, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorKeys.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorKeys.js new file mode 100644 index 0000000000000000000000000000000000000000..99442bddbf18869c21622e17948020a851bc6d51 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorKeys.js @@ -0,0 +1,10 @@ +function _regeneratorKeys(e) { + var n = Object(e), + r = []; + for (var t in n) r.unshift(t); + return function e() { + for (; r.length;) if ((t = r.pop()) in n) return e.value = t, e.done = !1, e; + return e.done = !0, e; + }; +} +module.exports = _regeneratorKeys, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorRuntime.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorRuntime.js new file mode 100644 index 0000000000000000000000000000000000000000..24baaa05a9c432f3671c3c05fa941b41e2bfd25c --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorRuntime.js @@ -0,0 +1,77 @@ +var OverloadYield = require("./OverloadYield.js"); +var regenerator = require("./regenerator.js"); +var regeneratorAsync = require("./regeneratorAsync.js"); +var regeneratorAsyncGen = require("./regeneratorAsyncGen.js"); +var regeneratorAsyncIterator = require("./regeneratorAsyncIterator.js"); +var regeneratorKeys = require("./regeneratorKeys.js"); +var regeneratorValues = require("./regeneratorValues.js"); +function _regeneratorRuntime() { + "use strict"; + + var r = regenerator(), + e = r.m(_regeneratorRuntime), + t = (Object.getPrototypeOf ? Object.getPrototypeOf(e) : e.__proto__).constructor; + function n(r) { + var e = "function" == typeof r && r.constructor; + return !!e && (e === t || "GeneratorFunction" === (e.displayName || e.name)); + } + var o = { + "throw": 1, + "return": 2, + "break": 3, + "continue": 3 + }; + function a(r) { + var e, t; + return function (n) { + e || (e = { + stop: function stop() { + return t(n.a, 2); + }, + "catch": function _catch() { + return n.v; + }, + abrupt: function abrupt(r, e) { + return t(n.a, o[r], e); + }, + delegateYield: function delegateYield(r, o, a) { + return e.resultName = o, t(n.d, regeneratorValues(r), a); + }, + finish: function finish(r) { + return t(n.f, r); + } + }, t = function t(r, _t, o) { + n.p = e.prev, n.n = e.next; + try { + return r(_t, o); + } finally { + e.next = n.n; + } + }), e.resultName && (e[e.resultName] = n.v, e.resultName = void 0), e.sent = n.v, e.next = n.n; + try { + return r.call(this, e); + } finally { + n.p = e.prev, n.n = e.next; + } + }; + } + return (module.exports = _regeneratorRuntime = function _regeneratorRuntime() { + return { + wrap: function wrap(e, t, n, o) { + return r.w(a(e), t, n, o && o.reverse()); + }, + isGeneratorFunction: n, + mark: r.m, + awrap: function awrap(r, e) { + return new OverloadYield(r, e); + }, + AsyncIterator: regeneratorAsyncIterator, + async: function async(r, e, t, o, u) { + return (n(e) ? regeneratorAsyncGen : regeneratorAsync)(a(r), e, t, o, u); + }, + keys: regeneratorKeys, + values: regeneratorValues + }; + }, module.exports.__esModule = true, module.exports["default"] = module.exports)(); +} +module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorValues.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorValues.js new file mode 100644 index 0000000000000000000000000000000000000000..1335a23d5bc02eeee7c5b090214e7f185b117224 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/regeneratorValues.js @@ -0,0 +1,19 @@ +var _typeof = require("./typeof.js")["default"]; +function _regeneratorValues(e) { + if (null != e) { + var t = e["function" == typeof Symbol && Symbol.iterator || "@@iterator"], + r = 0; + if (t) return t.call(e); + if ("function" == typeof e.next) return e; + if (!isNaN(e.length)) return { + next: function next() { + return e && r >= e.length && (e = void 0), { + value: e && e[r++], + done: !e + }; + } + }; + } + throw new TypeError(_typeof(e) + " is not iterable"); +} +module.exports = _regeneratorValues, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/set.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/set.js new file mode 100644 index 0000000000000000000000000000000000000000..6421470aa17e98983210b3fe2b69081bdb7d0d6e --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/set.js @@ -0,0 +1,22 @@ +var superPropBase = require("./superPropBase.js"); +var defineProperty = require("./defineProperty.js"); +function set(e, r, t, o) { + return set = "undefined" != typeof Reflect && Reflect.set ? Reflect.set : function (e, r, t, o) { + var f, + i = superPropBase(e, r); + if (i) { + if ((f = Object.getOwnPropertyDescriptor(i, r)).set) return f.set.call(o, t), !0; + if (!f.writable) return !1; + } + if (f = Object.getOwnPropertyDescriptor(o, r)) { + if (!f.writable) return !1; + f.value = t, Object.defineProperty(o, r, f); + } else defineProperty(o, r, t); + return !0; + }, set(e, r, t, o); +} +function _set(e, r, t, o, f) { + if (!set(e, r, t, o || e) && f) throw new TypeError("failed to set property"); + return t; +} +module.exports = _set, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/setFunctionName.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/setFunctionName.js new file mode 100644 index 0000000000000000000000000000000000000000..9664076a861f6fd4516d124a32924ed7eeccccee --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/setFunctionName.js @@ -0,0 +1,12 @@ +var _typeof = require("./typeof.js")["default"]; +function setFunctionName(e, t, n) { + "symbol" == _typeof(t) && (t = (t = t.description) ? "[" + t + "]" : ""); + try { + Object.defineProperty(e, "name", { + configurable: !0, + value: n ? n + " " + t : t + }); + } catch (e) {} + return e; +} +module.exports = setFunctionName, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/setPrototypeOf.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/setPrototypeOf.js new file mode 100644 index 0000000000000000000000000000000000000000..7d991ffa6f0966a0cb455959f0b736ccf445f9ac --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/setPrototypeOf.js @@ -0,0 +1,6 @@ +function _setPrototypeOf(t, e) { + return module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { + return t.__proto__ = e, t; + }, module.exports.__esModule = true, module.exports["default"] = module.exports, _setPrototypeOf(t, e); +} +module.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/skipFirstGeneratorNext.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/skipFirstGeneratorNext.js new file mode 100644 index 0000000000000000000000000000000000000000..2aed548efc8d5fffeb0c3d3f75f2e3df4f698bf7 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/skipFirstGeneratorNext.js @@ -0,0 +1,7 @@ +function _skipFirstGeneratorNext(t) { + return function () { + var r = t.apply(this, arguments); + return r.next(), r; + }; +} +module.exports = _skipFirstGeneratorNext, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/slicedToArray.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/slicedToArray.js new file mode 100644 index 0000000000000000000000000000000000000000..3d752c4251abfe03fdbb9bc1a8965e4779f0d8e2 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/slicedToArray.js @@ -0,0 +1,8 @@ +var arrayWithHoles = require("./arrayWithHoles.js"); +var iterableToArrayLimit = require("./iterableToArrayLimit.js"); +var unsupportedIterableToArray = require("./unsupportedIterableToArray.js"); +var nonIterableRest = require("./nonIterableRest.js"); +function _slicedToArray(r, e) { + return arrayWithHoles(r) || iterableToArrayLimit(r, e) || unsupportedIterableToArray(r, e) || nonIterableRest(); +} +module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/superPropBase.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/superPropBase.js new file mode 100644 index 0000000000000000000000000000000000000000..5cad45953f6a6348a5ea3f5bcebdaf60e3778226 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/superPropBase.js @@ -0,0 +1,6 @@ +var getPrototypeOf = require("./getPrototypeOf.js"); +function _superPropBase(t, o) { + for (; !{}.hasOwnProperty.call(t, o) && null !== (t = getPrototypeOf(t));); + return t; +} +module.exports = _superPropBase, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/superPropGet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/superPropGet.js new file mode 100644 index 0000000000000000000000000000000000000000..baf8b1024cf484ec5e1ab14418bd3efb6696d067 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/superPropGet.js @@ -0,0 +1,9 @@ +var get = require("./get.js"); +var getPrototypeOf = require("./getPrototypeOf.js"); +function _superPropGet(t, o, e, r) { + var p = get(getPrototypeOf(1 & r ? t.prototype : t), o, e); + return 2 & r && "function" == typeof p ? function (t) { + return p.apply(e, t); + } : p; +} +module.exports = _superPropGet, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/superPropSet.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/superPropSet.js new file mode 100644 index 0000000000000000000000000000000000000000..e0578c049039e7f286bbe0b81716e116e174131f --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/superPropSet.js @@ -0,0 +1,6 @@ +var set = require("./set.js"); +var getPrototypeOf = require("./getPrototypeOf.js"); +function _superPropSet(t, e, o, r, p, f) { + return set(getPrototypeOf(f ? t.prototype : t), e, o, r, p); +} +module.exports = _superPropSet, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/taggedTemplateLiteral.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/taggedTemplateLiteral.js new file mode 100644 index 0000000000000000000000000000000000000000..38d6065ae92ab78b0dde3aabcc4fd1986910cb30 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/taggedTemplateLiteral.js @@ -0,0 +1,8 @@ +function _taggedTemplateLiteral(e, t) { + return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, { + raw: { + value: Object.freeze(t) + } + })); +} +module.exports = _taggedTemplateLiteral, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/taggedTemplateLiteralLoose.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/taggedTemplateLiteralLoose.js new file mode 100644 index 0000000000000000000000000000000000000000..2f8c146aece3a14910cd934c593f9e2d0c2c5f22 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/taggedTemplateLiteralLoose.js @@ -0,0 +1,4 @@ +function _taggedTemplateLiteralLoose(e, t) { + return t || (t = e.slice(0)), e.raw = t, e; +} +module.exports = _taggedTemplateLiteralLoose, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/tdz.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/tdz.js new file mode 100644 index 0000000000000000000000000000000000000000..c66f476c6c10d5ea7685d92f7311d04a5a68ee9b --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/tdz.js @@ -0,0 +1,4 @@ +function _tdzError(e) { + throw new ReferenceError(e + " is not defined - temporal dead zone"); +} +module.exports = _tdzError, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/temporalRef.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/temporalRef.js new file mode 100644 index 0000000000000000000000000000000000000000..54c9190c4aca91f7128fdb8404fe6c23eca47183 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/temporalRef.js @@ -0,0 +1,6 @@ +var temporalUndefined = require("./temporalUndefined.js"); +var tdz = require("./tdz.js"); +function _temporalRef(r, e) { + return r === temporalUndefined ? tdz(e) : r; +} +module.exports = _temporalRef, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/temporalUndefined.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/temporalUndefined.js new file mode 100644 index 0000000000000000000000000000000000000000..f8def80021dbb3f39d3ad67730c2ad87e7748c6d --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/temporalUndefined.js @@ -0,0 +1,2 @@ +function _temporalUndefined() {} +module.exports = _temporalUndefined, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/toArray.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/toArray.js new file mode 100644 index 0000000000000000000000000000000000000000..2be1d2bd70286b66a52a317643e8d843e4d58a54 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/toArray.js @@ -0,0 +1,8 @@ +var arrayWithHoles = require("./arrayWithHoles.js"); +var iterableToArray = require("./iterableToArray.js"); +var unsupportedIterableToArray = require("./unsupportedIterableToArray.js"); +var nonIterableRest = require("./nonIterableRest.js"); +function _toArray(r) { + return arrayWithHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableRest(); +} +module.exports = _toArray, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/toConsumableArray.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/toConsumableArray.js new file mode 100644 index 0000000000000000000000000000000000000000..698f9c69c29bd6d0112c46275dd0f99bd228268c --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/toConsumableArray.js @@ -0,0 +1,8 @@ +var arrayWithoutHoles = require("./arrayWithoutHoles.js"); +var iterableToArray = require("./iterableToArray.js"); +var unsupportedIterableToArray = require("./unsupportedIterableToArray.js"); +var nonIterableSpread = require("./nonIterableSpread.js"); +function _toConsumableArray(r) { + return arrayWithoutHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableSpread(); +} +module.exports = _toConsumableArray, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/toPrimitive.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/toPrimitive.js new file mode 100644 index 0000000000000000000000000000000000000000..ef9d249b5cb2fba37c43154f56c3d9b282b994dc --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/toPrimitive.js @@ -0,0 +1,12 @@ +var _typeof = require("./typeof.js")["default"]; +function toPrimitive(t, r) { + if ("object" != _typeof(t) || !t) return t; + var e = t[Symbol.toPrimitive]; + if (void 0 !== e) { + var i = e.call(t, r || "default"); + if ("object" != _typeof(i)) return i; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return ("string" === r ? String : Number)(t); +} +module.exports = toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/toPropertyKey.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/toPropertyKey.js new file mode 100644 index 0000000000000000000000000000000000000000..3ca3d4fcba6752a10a4defbd2ab146215fc19d58 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/toPropertyKey.js @@ -0,0 +1,7 @@ +var _typeof = require("./typeof.js")["default"]; +var toPrimitive = require("./toPrimitive.js"); +function toPropertyKey(t) { + var i = toPrimitive(t, "string"); + return "symbol" == _typeof(i) ? i : i + ""; +} +module.exports = toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/toSetter.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/toSetter.js new file mode 100644 index 0000000000000000000000000000000000000000..e0012a8f8fc7d92fceb1eda1ff47607e3078c205 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/toSetter.js @@ -0,0 +1,10 @@ +function _toSetter(t, e, n) { + e || (e = []); + var r = e.length++; + return Object.defineProperty({}, "_", { + set: function set(o) { + e[r] = o, t.apply(n, e); + } + }); +} +module.exports = _toSetter, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/tsRewriteRelativeImportExtensions.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/tsRewriteRelativeImportExtensions.js new file mode 100644 index 0000000000000000000000000000000000000000..4de0e4de81a1851d9ca15d9aa7ce6055c3766a0f --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/tsRewriteRelativeImportExtensions.js @@ -0,0 +1,6 @@ +function tsRewriteRelativeImportExtensions(t, e) { + return "string" == typeof t && /^\.\.?\//.test(t) ? t.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+)?)\.([cm]?)ts$/i, function (t, s, r, n, o) { + return s ? e ? ".jsx" : ".js" : !r || n && o ? r + n + "." + o.toLowerCase() + "js" : t; + }) : t; +} +module.exports = tsRewriteRelativeImportExtensions, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/typeof.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/typeof.js new file mode 100644 index 0000000000000000000000000000000000000000..b6fbfaf8c102a66332e3d899c2e688eb80c52c69 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/typeof.js @@ -0,0 +1,10 @@ +function _typeof(o) { + "@babel/helpers - typeof"; + + return module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { + return typeof o; + } : function (o) { + return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; + }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof(o); +} +module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js new file mode 100644 index 0000000000000000000000000000000000000000..8fb1a71de61213141368a8341f9140bdb4b6bc20 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js @@ -0,0 +1,9 @@ +var arrayLikeToArray = require("./arrayLikeToArray.js"); +function _unsupportedIterableToArray(r, a) { + if (r) { + if ("string" == typeof r) return arrayLikeToArray(r, a); + var t = {}.toString.call(r).slice(8, -1); + return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, a) : void 0; + } +} +module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/using.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/using.js new file mode 100644 index 0000000000000000000000000000000000000000..37c79e2c17d74f89638d26166d75b83fbb4c17af --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/using.js @@ -0,0 +1,12 @@ +function _using(o, n, e) { + if (null == n) return n; + if (Object(n) !== n) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined."); + if (e) var r = n[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")]; + if (null == r && (r = n[Symbol.dispose || Symbol["for"]("Symbol.dispose")]), "function" != typeof r) throw new TypeError("Property [Symbol.dispose] is not a function."); + return o.push({ + v: n, + d: r, + a: e + }), n; +} +module.exports = _using, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/usingCtx.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/usingCtx.js new file mode 100644 index 0000000000000000000000000000000000000000..652ab15d5494264f449ca38486cc47dd7fdeb420 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/usingCtx.js @@ -0,0 +1,59 @@ +function _usingCtx() { + var r = "function" == typeof SuppressedError ? SuppressedError : function (r, e) { + var n = Error(); + return n.name = "SuppressedError", n.error = r, n.suppressed = e, n; + }, + e = {}, + n = []; + function using(r, e) { + if (null != e) { + if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined."); + if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")]; + if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o; + if ("function" != typeof o) throw new TypeError("Object is not disposable."); + t && (o = function o() { + try { + t.call(e); + } catch (r) { + return Promise.reject(r); + } + }), n.push({ + v: e, + d: o, + a: r + }); + } else r && n.push({ + d: e, + a: r + }); + return e; + } + return { + e: e, + u: using.bind(null, !1), + a: using.bind(null, !0), + d: function d() { + var o, + t = this.e, + s = 0; + function next() { + for (; o = n.pop();) try { + if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next); + if (o.d) { + var r = o.d.call(o.v); + if (o.a) return s |= 2, Promise.resolve(r).then(next, err); + } else s |= 1; + } catch (r) { + return err(r); + } + if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve(); + if (t !== e) throw t; + } + function err(n) { + return t = t !== e ? new r(n, t) : n, next(); + } + return next(); + } + }; +} +module.exports = _usingCtx, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/wrapAsyncGenerator.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/wrapAsyncGenerator.js new file mode 100644 index 0000000000000000000000000000000000000000..b818e2e4a0dcc9c5d731b4e53cac7651c7d982b6 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/wrapAsyncGenerator.js @@ -0,0 +1,69 @@ +var OverloadYield = require("./OverloadYield.js"); +function _wrapAsyncGenerator(e) { + return function () { + return new AsyncGenerator(e.apply(this, arguments)); + }; +} +function AsyncGenerator(e) { + var r, t; + function resume(r, t) { + try { + var n = e[r](t), + o = n.value, + u = o instanceof OverloadYield; + Promise.resolve(u ? o.v : o).then(function (t) { + if (u) { + var i = "return" === r ? "return" : "next"; + if (!o.k || t.done) return resume(i, t); + t = e[i](t).value; + } + settle(n.done ? "return" : "normal", t); + }, function (e) { + resume("throw", e); + }); + } catch (e) { + settle("throw", e); + } + } + function settle(e, n) { + switch (e) { + case "return": + r.resolve({ + value: n, + done: !0 + }); + break; + case "throw": + r.reject(n); + break; + default: + r.resolve({ + value: n, + done: !1 + }); + } + (r = r.next) ? resume(r.key, r.arg) : t = null; + } + this._invoke = function (e, n) { + return new Promise(function (o, u) { + var i = { + key: e, + arg: n, + resolve: o, + reject: u, + next: null + }; + t ? t = t.next = i : (r = t = i, resume(e, n)); + }); + }, "function" != typeof e["return"] && (this["return"] = void 0); +} +AsyncGenerator.prototype["function" == typeof Symbol && Symbol.asyncIterator || "@@asyncIterator"] = function () { + return this; +}, AsyncGenerator.prototype.next = function (e) { + return this._invoke("next", e); +}, AsyncGenerator.prototype["throw"] = function (e) { + return this._invoke("throw", e); +}, AsyncGenerator.prototype["return"] = function (e) { + return this._invoke("return", e); +}; +module.exports = _wrapAsyncGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/wrapNativeSuper.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/wrapNativeSuper.js new file mode 100644 index 0000000000000000000000000000000000000000..acd87aba61f46a45c9946d62113c14cd892ae33a --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/wrapNativeSuper.js @@ -0,0 +1,27 @@ +var getPrototypeOf = require("./getPrototypeOf.js"); +var setPrototypeOf = require("./setPrototypeOf.js"); +var isNativeFunction = require("./isNativeFunction.js"); +var construct = require("./construct.js"); +function _wrapNativeSuper(t) { + var r = "function" == typeof Map ? new Map() : void 0; + return module.exports = _wrapNativeSuper = function _wrapNativeSuper(t) { + if (null === t || !isNativeFunction(t)) return t; + if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function"); + if (void 0 !== r) { + if (r.has(t)) return r.get(t); + r.set(t, Wrapper); + } + function Wrapper() { + return construct(t, arguments, getPrototypeOf(this).constructor); + } + return Wrapper.prototype = Object.create(t.prototype, { + constructor: { + value: Wrapper, + enumerable: !1, + writable: !0, + configurable: !0 + } + }), setPrototypeOf(Wrapper, t); + }, module.exports.__esModule = true, module.exports["default"] = module.exports, _wrapNativeSuper(t); +} +module.exports = _wrapNativeSuper, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/wrapRegExp.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/wrapRegExp.js new file mode 100644 index 0000000000000000000000000000000000000000..3d6e6ce5ec7b6242bc22d3bc505ea305a0ee60b2 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/wrapRegExp.js @@ -0,0 +1,52 @@ +var _typeof = require("./typeof.js")["default"]; +var setPrototypeOf = require("./setPrototypeOf.js"); +var inherits = require("./inherits.js"); +function _wrapRegExp() { + module.exports = _wrapRegExp = function _wrapRegExp(e, r) { + return new BabelRegExp(e, void 0, r); + }, module.exports.__esModule = true, module.exports["default"] = module.exports; + var e = RegExp.prototype, + r = new WeakMap(); + function BabelRegExp(e, t, p) { + var o = RegExp(e, t); + return r.set(o, p || r.get(e)), setPrototypeOf(o, BabelRegExp.prototype); + } + function buildGroups(e, t) { + var p = r.get(t); + return Object.keys(p).reduce(function (r, t) { + var o = p[t]; + if ("number" == typeof o) r[t] = e[o];else { + for (var i = 0; void 0 === e[o[i]] && i + 1 < o.length;) i++; + r[t] = e[o[i]]; + } + return r; + }, Object.create(null)); + } + return inherits(BabelRegExp, RegExp), BabelRegExp.prototype.exec = function (r) { + var t = e.exec.call(this, r); + if (t) { + t.groups = buildGroups(t, this); + var p = t.indices; + p && (p.groups = buildGroups(p, this)); + } + return t; + }, BabelRegExp.prototype[Symbol.replace] = function (t, p) { + if ("string" == typeof p) { + var o = r.get(this); + return e[Symbol.replace].call(this, t, p.replace(/\$<([^>]+)(>|$)/g, function (e, r, t) { + if ("" === t) return e; + var p = o[r]; + return Array.isArray(p) ? "$" + p.join("$") : "number" == typeof p ? "$" + p : ""; + })); + } + if ("function" == typeof p) { + var i = this; + return e[Symbol.replace].call(this, t, function () { + var e = arguments; + return "object" != _typeof(e[e.length - 1]) && (e = [].slice.call(e)).push(buildGroups(e, i)), p.apply(this, e); + }); + } + return e[Symbol.replace].call(this, t, p); + }, _wrapRegExp.apply(this, arguments); +} +module.exports = _wrapRegExp, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/writeOnlyError.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/writeOnlyError.js new file mode 100644 index 0000000000000000000000000000000000000000..c98ee825dc33bac8498ba0799587cf994f6893bc --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/helpers/writeOnlyError.js @@ -0,0 +1,4 @@ +function _writeOnlyError(r) { + throw new TypeError('"' + r + '" is write-only'); +} +module.exports = _writeOnlyError, module.exports.__esModule = true, module.exports["default"] = module.exports; \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/package.json b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/package.json new file mode 100644 index 0000000000000000000000000000000000000000..166ba20fa73140eeb1193ddb5d7a2a7dde0d7f16 --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/package.json @@ -0,0 +1,1107 @@ +{ + "name": "@babel/runtime", + "version": "7.28.2", + "description": "babel's modular runtime helpers", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-runtime" + }, + "homepage": "https://babel.dev/docs/en/next/babel-runtime", + "author": "The Babel Team (https://babel.dev/team)", + "exports": { + "./helpers/OverloadYield": [ + { + "node": "./helpers/OverloadYield.js", + "import": "./helpers/esm/OverloadYield.js", + "default": "./helpers/OverloadYield.js" + }, + "./helpers/OverloadYield.js" + ], + "./helpers/esm/OverloadYield": "./helpers/esm/OverloadYield.js", + "./helpers/applyDecoratedDescriptor": [ + { + "node": "./helpers/applyDecoratedDescriptor.js", + "import": "./helpers/esm/applyDecoratedDescriptor.js", + "default": "./helpers/applyDecoratedDescriptor.js" + }, + "./helpers/applyDecoratedDescriptor.js" + ], + "./helpers/esm/applyDecoratedDescriptor": "./helpers/esm/applyDecoratedDescriptor.js", + "./helpers/applyDecs2311": [ + { + "node": "./helpers/applyDecs2311.js", + "import": "./helpers/esm/applyDecs2311.js", + "default": "./helpers/applyDecs2311.js" + }, + "./helpers/applyDecs2311.js" + ], + "./helpers/esm/applyDecs2311": "./helpers/esm/applyDecs2311.js", + "./helpers/arrayLikeToArray": [ + { + "node": "./helpers/arrayLikeToArray.js", + "import": "./helpers/esm/arrayLikeToArray.js", + "default": "./helpers/arrayLikeToArray.js" + }, + "./helpers/arrayLikeToArray.js" + ], + "./helpers/esm/arrayLikeToArray": "./helpers/esm/arrayLikeToArray.js", + "./helpers/arrayWithHoles": [ + { + "node": "./helpers/arrayWithHoles.js", + "import": "./helpers/esm/arrayWithHoles.js", + "default": "./helpers/arrayWithHoles.js" + }, + "./helpers/arrayWithHoles.js" + ], + "./helpers/esm/arrayWithHoles": "./helpers/esm/arrayWithHoles.js", + "./helpers/arrayWithoutHoles": [ + { + "node": "./helpers/arrayWithoutHoles.js", + "import": "./helpers/esm/arrayWithoutHoles.js", + "default": "./helpers/arrayWithoutHoles.js" + }, + "./helpers/arrayWithoutHoles.js" + ], + "./helpers/esm/arrayWithoutHoles": "./helpers/esm/arrayWithoutHoles.js", + "./helpers/assertClassBrand": [ + { + "node": "./helpers/assertClassBrand.js", + "import": "./helpers/esm/assertClassBrand.js", + "default": "./helpers/assertClassBrand.js" + }, + "./helpers/assertClassBrand.js" + ], + "./helpers/esm/assertClassBrand": "./helpers/esm/assertClassBrand.js", + "./helpers/assertThisInitialized": [ + { + "node": "./helpers/assertThisInitialized.js", + "import": "./helpers/esm/assertThisInitialized.js", + "default": "./helpers/assertThisInitialized.js" + }, + "./helpers/assertThisInitialized.js" + ], + "./helpers/esm/assertThisInitialized": "./helpers/esm/assertThisInitialized.js", + "./helpers/asyncGeneratorDelegate": [ + { + "node": "./helpers/asyncGeneratorDelegate.js", + "import": "./helpers/esm/asyncGeneratorDelegate.js", + "default": "./helpers/asyncGeneratorDelegate.js" + }, + "./helpers/asyncGeneratorDelegate.js" + ], + "./helpers/esm/asyncGeneratorDelegate": "./helpers/esm/asyncGeneratorDelegate.js", + "./helpers/asyncIterator": [ + { + "node": "./helpers/asyncIterator.js", + "import": "./helpers/esm/asyncIterator.js", + "default": "./helpers/asyncIterator.js" + }, + "./helpers/asyncIterator.js" + ], + "./helpers/esm/asyncIterator": "./helpers/esm/asyncIterator.js", + "./helpers/asyncToGenerator": [ + { + "node": "./helpers/asyncToGenerator.js", + "import": "./helpers/esm/asyncToGenerator.js", + "default": "./helpers/asyncToGenerator.js" + }, + "./helpers/asyncToGenerator.js" + ], + "./helpers/esm/asyncToGenerator": "./helpers/esm/asyncToGenerator.js", + "./helpers/awaitAsyncGenerator": [ + { + "node": "./helpers/awaitAsyncGenerator.js", + "import": "./helpers/esm/awaitAsyncGenerator.js", + "default": "./helpers/awaitAsyncGenerator.js" + }, + "./helpers/awaitAsyncGenerator.js" + ], + "./helpers/esm/awaitAsyncGenerator": "./helpers/esm/awaitAsyncGenerator.js", + "./helpers/callSuper": [ + { + "node": "./helpers/callSuper.js", + "import": "./helpers/esm/callSuper.js", + "default": "./helpers/callSuper.js" + }, + "./helpers/callSuper.js" + ], + "./helpers/esm/callSuper": "./helpers/esm/callSuper.js", + "./helpers/checkInRHS": [ + { + "node": "./helpers/checkInRHS.js", + "import": "./helpers/esm/checkInRHS.js", + "default": "./helpers/checkInRHS.js" + }, + "./helpers/checkInRHS.js" + ], + "./helpers/esm/checkInRHS": "./helpers/esm/checkInRHS.js", + "./helpers/checkPrivateRedeclaration": [ + { + "node": "./helpers/checkPrivateRedeclaration.js", + "import": "./helpers/esm/checkPrivateRedeclaration.js", + "default": "./helpers/checkPrivateRedeclaration.js" + }, + "./helpers/checkPrivateRedeclaration.js" + ], + "./helpers/esm/checkPrivateRedeclaration": "./helpers/esm/checkPrivateRedeclaration.js", + "./helpers/classCallCheck": [ + { + "node": "./helpers/classCallCheck.js", + "import": "./helpers/esm/classCallCheck.js", + "default": "./helpers/classCallCheck.js" + }, + "./helpers/classCallCheck.js" + ], + "./helpers/esm/classCallCheck": "./helpers/esm/classCallCheck.js", + "./helpers/classNameTDZError": [ + { + "node": "./helpers/classNameTDZError.js", + "import": "./helpers/esm/classNameTDZError.js", + "default": "./helpers/classNameTDZError.js" + }, + "./helpers/classNameTDZError.js" + ], + "./helpers/esm/classNameTDZError": "./helpers/esm/classNameTDZError.js", + "./helpers/classPrivateFieldGet2": [ + { + "node": "./helpers/classPrivateFieldGet2.js", + "import": "./helpers/esm/classPrivateFieldGet2.js", + "default": "./helpers/classPrivateFieldGet2.js" + }, + "./helpers/classPrivateFieldGet2.js" + ], + "./helpers/esm/classPrivateFieldGet2": "./helpers/esm/classPrivateFieldGet2.js", + "./helpers/classPrivateFieldInitSpec": [ + { + "node": "./helpers/classPrivateFieldInitSpec.js", + "import": "./helpers/esm/classPrivateFieldInitSpec.js", + "default": "./helpers/classPrivateFieldInitSpec.js" + }, + "./helpers/classPrivateFieldInitSpec.js" + ], + "./helpers/esm/classPrivateFieldInitSpec": "./helpers/esm/classPrivateFieldInitSpec.js", + "./helpers/classPrivateFieldLooseBase": [ + { + "node": "./helpers/classPrivateFieldLooseBase.js", + "import": "./helpers/esm/classPrivateFieldLooseBase.js", + "default": "./helpers/classPrivateFieldLooseBase.js" + }, + "./helpers/classPrivateFieldLooseBase.js" + ], + "./helpers/esm/classPrivateFieldLooseBase": "./helpers/esm/classPrivateFieldLooseBase.js", + "./helpers/classPrivateFieldLooseKey": [ + { + "node": "./helpers/classPrivateFieldLooseKey.js", + "import": "./helpers/esm/classPrivateFieldLooseKey.js", + "default": "./helpers/classPrivateFieldLooseKey.js" + }, + "./helpers/classPrivateFieldLooseKey.js" + ], + "./helpers/esm/classPrivateFieldLooseKey": "./helpers/esm/classPrivateFieldLooseKey.js", + "./helpers/classPrivateFieldSet2": [ + { + "node": "./helpers/classPrivateFieldSet2.js", + "import": "./helpers/esm/classPrivateFieldSet2.js", + "default": "./helpers/classPrivateFieldSet2.js" + }, + "./helpers/classPrivateFieldSet2.js" + ], + "./helpers/esm/classPrivateFieldSet2": "./helpers/esm/classPrivateFieldSet2.js", + "./helpers/classPrivateGetter": [ + { + "node": "./helpers/classPrivateGetter.js", + "import": "./helpers/esm/classPrivateGetter.js", + "default": "./helpers/classPrivateGetter.js" + }, + "./helpers/classPrivateGetter.js" + ], + "./helpers/esm/classPrivateGetter": "./helpers/esm/classPrivateGetter.js", + "./helpers/classPrivateMethodInitSpec": [ + { + "node": "./helpers/classPrivateMethodInitSpec.js", + "import": "./helpers/esm/classPrivateMethodInitSpec.js", + "default": "./helpers/classPrivateMethodInitSpec.js" + }, + "./helpers/classPrivateMethodInitSpec.js" + ], + "./helpers/esm/classPrivateMethodInitSpec": "./helpers/esm/classPrivateMethodInitSpec.js", + "./helpers/classPrivateSetter": [ + { + "node": "./helpers/classPrivateSetter.js", + "import": "./helpers/esm/classPrivateSetter.js", + "default": "./helpers/classPrivateSetter.js" + }, + "./helpers/classPrivateSetter.js" + ], + "./helpers/esm/classPrivateSetter": "./helpers/esm/classPrivateSetter.js", + "./helpers/classStaticPrivateMethodGet": [ + { + "node": "./helpers/classStaticPrivateMethodGet.js", + "import": "./helpers/esm/classStaticPrivateMethodGet.js", + "default": "./helpers/classStaticPrivateMethodGet.js" + }, + "./helpers/classStaticPrivateMethodGet.js" + ], + "./helpers/esm/classStaticPrivateMethodGet": "./helpers/esm/classStaticPrivateMethodGet.js", + "./helpers/construct": [ + { + "node": "./helpers/construct.js", + "import": "./helpers/esm/construct.js", + "default": "./helpers/construct.js" + }, + "./helpers/construct.js" + ], + "./helpers/esm/construct": "./helpers/esm/construct.js", + "./helpers/createClass": [ + { + "node": "./helpers/createClass.js", + "import": "./helpers/esm/createClass.js", + "default": "./helpers/createClass.js" + }, + "./helpers/createClass.js" + ], + "./helpers/esm/createClass": "./helpers/esm/createClass.js", + "./helpers/createForOfIteratorHelper": [ + { + "node": "./helpers/createForOfIteratorHelper.js", + "import": "./helpers/esm/createForOfIteratorHelper.js", + "default": "./helpers/createForOfIteratorHelper.js" + }, + "./helpers/createForOfIteratorHelper.js" + ], + "./helpers/esm/createForOfIteratorHelper": "./helpers/esm/createForOfIteratorHelper.js", + "./helpers/createForOfIteratorHelperLoose": [ + { + "node": "./helpers/createForOfIteratorHelperLoose.js", + "import": "./helpers/esm/createForOfIteratorHelperLoose.js", + "default": "./helpers/createForOfIteratorHelperLoose.js" + }, + "./helpers/createForOfIteratorHelperLoose.js" + ], + "./helpers/esm/createForOfIteratorHelperLoose": "./helpers/esm/createForOfIteratorHelperLoose.js", + "./helpers/createSuper": [ + { + "node": "./helpers/createSuper.js", + "import": "./helpers/esm/createSuper.js", + "default": "./helpers/createSuper.js" + }, + "./helpers/createSuper.js" + ], + "./helpers/esm/createSuper": "./helpers/esm/createSuper.js", + "./helpers/decorate": [ + { + "node": "./helpers/decorate.js", + "import": "./helpers/esm/decorate.js", + "default": "./helpers/decorate.js" + }, + "./helpers/decorate.js" + ], + "./helpers/esm/decorate": "./helpers/esm/decorate.js", + "./helpers/defaults": [ + { + "node": "./helpers/defaults.js", + "import": "./helpers/esm/defaults.js", + "default": "./helpers/defaults.js" + }, + "./helpers/defaults.js" + ], + "./helpers/esm/defaults": "./helpers/esm/defaults.js", + "./helpers/defineAccessor": [ + { + "node": "./helpers/defineAccessor.js", + "import": "./helpers/esm/defineAccessor.js", + "default": "./helpers/defineAccessor.js" + }, + "./helpers/defineAccessor.js" + ], + "./helpers/esm/defineAccessor": "./helpers/esm/defineAccessor.js", + "./helpers/defineProperty": [ + { + "node": "./helpers/defineProperty.js", + "import": "./helpers/esm/defineProperty.js", + "default": "./helpers/defineProperty.js" + }, + "./helpers/defineProperty.js" + ], + "./helpers/esm/defineProperty": "./helpers/esm/defineProperty.js", + "./helpers/extends": [ + { + "node": "./helpers/extends.js", + "import": "./helpers/esm/extends.js", + "default": "./helpers/extends.js" + }, + "./helpers/extends.js" + ], + "./helpers/esm/extends": "./helpers/esm/extends.js", + "./helpers/get": [ + { + "node": "./helpers/get.js", + "import": "./helpers/esm/get.js", + "default": "./helpers/get.js" + }, + "./helpers/get.js" + ], + "./helpers/esm/get": "./helpers/esm/get.js", + "./helpers/getPrototypeOf": [ + { + "node": "./helpers/getPrototypeOf.js", + "import": "./helpers/esm/getPrototypeOf.js", + "default": "./helpers/getPrototypeOf.js" + }, + "./helpers/getPrototypeOf.js" + ], + "./helpers/esm/getPrototypeOf": "./helpers/esm/getPrototypeOf.js", + "./helpers/identity": [ + { + "node": "./helpers/identity.js", + "import": "./helpers/esm/identity.js", + "default": "./helpers/identity.js" + }, + "./helpers/identity.js" + ], + "./helpers/esm/identity": "./helpers/esm/identity.js", + "./helpers/importDeferProxy": [ + { + "node": "./helpers/importDeferProxy.js", + "import": "./helpers/esm/importDeferProxy.js", + "default": "./helpers/importDeferProxy.js" + }, + "./helpers/importDeferProxy.js" + ], + "./helpers/esm/importDeferProxy": "./helpers/esm/importDeferProxy.js", + "./helpers/inherits": [ + { + "node": "./helpers/inherits.js", + "import": "./helpers/esm/inherits.js", + "default": "./helpers/inherits.js" + }, + "./helpers/inherits.js" + ], + "./helpers/esm/inherits": "./helpers/esm/inherits.js", + "./helpers/inheritsLoose": [ + { + "node": "./helpers/inheritsLoose.js", + "import": "./helpers/esm/inheritsLoose.js", + "default": "./helpers/inheritsLoose.js" + }, + "./helpers/inheritsLoose.js" + ], + "./helpers/esm/inheritsLoose": "./helpers/esm/inheritsLoose.js", + "./helpers/initializerDefineProperty": [ + { + "node": "./helpers/initializerDefineProperty.js", + "import": "./helpers/esm/initializerDefineProperty.js", + "default": "./helpers/initializerDefineProperty.js" + }, + "./helpers/initializerDefineProperty.js" + ], + "./helpers/esm/initializerDefineProperty": "./helpers/esm/initializerDefineProperty.js", + "./helpers/initializerWarningHelper": [ + { + "node": "./helpers/initializerWarningHelper.js", + "import": "./helpers/esm/initializerWarningHelper.js", + "default": "./helpers/initializerWarningHelper.js" + }, + "./helpers/initializerWarningHelper.js" + ], + "./helpers/esm/initializerWarningHelper": "./helpers/esm/initializerWarningHelper.js", + "./helpers/instanceof": [ + { + "node": "./helpers/instanceof.js", + "import": "./helpers/esm/instanceof.js", + "default": "./helpers/instanceof.js" + }, + "./helpers/instanceof.js" + ], + "./helpers/esm/instanceof": "./helpers/esm/instanceof.js", + "./helpers/interopRequireDefault": [ + { + "node": "./helpers/interopRequireDefault.js", + "import": "./helpers/esm/interopRequireDefault.js", + "default": "./helpers/interopRequireDefault.js" + }, + "./helpers/interopRequireDefault.js" + ], + "./helpers/esm/interopRequireDefault": "./helpers/esm/interopRequireDefault.js", + "./helpers/interopRequireWildcard": [ + { + "node": "./helpers/interopRequireWildcard.js", + "import": "./helpers/esm/interopRequireWildcard.js", + "default": "./helpers/interopRequireWildcard.js" + }, + "./helpers/interopRequireWildcard.js" + ], + "./helpers/esm/interopRequireWildcard": "./helpers/esm/interopRequireWildcard.js", + "./helpers/isNativeFunction": [ + { + "node": "./helpers/isNativeFunction.js", + "import": "./helpers/esm/isNativeFunction.js", + "default": "./helpers/isNativeFunction.js" + }, + "./helpers/isNativeFunction.js" + ], + "./helpers/esm/isNativeFunction": "./helpers/esm/isNativeFunction.js", + "./helpers/isNativeReflectConstruct": [ + { + "node": "./helpers/isNativeReflectConstruct.js", + "import": "./helpers/esm/isNativeReflectConstruct.js", + "default": "./helpers/isNativeReflectConstruct.js" + }, + "./helpers/isNativeReflectConstruct.js" + ], + "./helpers/esm/isNativeReflectConstruct": "./helpers/esm/isNativeReflectConstruct.js", + "./helpers/iterableToArray": [ + { + "node": "./helpers/iterableToArray.js", + "import": "./helpers/esm/iterableToArray.js", + "default": "./helpers/iterableToArray.js" + }, + "./helpers/iterableToArray.js" + ], + "./helpers/esm/iterableToArray": "./helpers/esm/iterableToArray.js", + "./helpers/iterableToArrayLimit": [ + { + "node": "./helpers/iterableToArrayLimit.js", + "import": "./helpers/esm/iterableToArrayLimit.js", + "default": "./helpers/iterableToArrayLimit.js" + }, + "./helpers/iterableToArrayLimit.js" + ], + "./helpers/esm/iterableToArrayLimit": "./helpers/esm/iterableToArrayLimit.js", + "./helpers/jsx": [ + { + "node": "./helpers/jsx.js", + "import": "./helpers/esm/jsx.js", + "default": "./helpers/jsx.js" + }, + "./helpers/jsx.js" + ], + "./helpers/esm/jsx": "./helpers/esm/jsx.js", + "./helpers/maybeArrayLike": [ + { + "node": "./helpers/maybeArrayLike.js", + "import": "./helpers/esm/maybeArrayLike.js", + "default": "./helpers/maybeArrayLike.js" + }, + "./helpers/maybeArrayLike.js" + ], + "./helpers/esm/maybeArrayLike": "./helpers/esm/maybeArrayLike.js", + "./helpers/newArrowCheck": [ + { + "node": "./helpers/newArrowCheck.js", + "import": "./helpers/esm/newArrowCheck.js", + "default": "./helpers/newArrowCheck.js" + }, + "./helpers/newArrowCheck.js" + ], + "./helpers/esm/newArrowCheck": "./helpers/esm/newArrowCheck.js", + "./helpers/nonIterableRest": [ + { + "node": "./helpers/nonIterableRest.js", + "import": "./helpers/esm/nonIterableRest.js", + "default": "./helpers/nonIterableRest.js" + }, + "./helpers/nonIterableRest.js" + ], + "./helpers/esm/nonIterableRest": "./helpers/esm/nonIterableRest.js", + "./helpers/nonIterableSpread": [ + { + "node": "./helpers/nonIterableSpread.js", + "import": "./helpers/esm/nonIterableSpread.js", + "default": "./helpers/nonIterableSpread.js" + }, + "./helpers/nonIterableSpread.js" + ], + "./helpers/esm/nonIterableSpread": "./helpers/esm/nonIterableSpread.js", + "./helpers/nullishReceiverError": [ + { + "node": "./helpers/nullishReceiverError.js", + "import": "./helpers/esm/nullishReceiverError.js", + "default": "./helpers/nullishReceiverError.js" + }, + "./helpers/nullishReceiverError.js" + ], + "./helpers/esm/nullishReceiverError": "./helpers/esm/nullishReceiverError.js", + "./helpers/objectDestructuringEmpty": [ + { + "node": "./helpers/objectDestructuringEmpty.js", + "import": "./helpers/esm/objectDestructuringEmpty.js", + "default": "./helpers/objectDestructuringEmpty.js" + }, + "./helpers/objectDestructuringEmpty.js" + ], + "./helpers/esm/objectDestructuringEmpty": "./helpers/esm/objectDestructuringEmpty.js", + "./helpers/objectSpread2": [ + { + "node": "./helpers/objectSpread2.js", + "import": "./helpers/esm/objectSpread2.js", + "default": "./helpers/objectSpread2.js" + }, + "./helpers/objectSpread2.js" + ], + "./helpers/esm/objectSpread2": "./helpers/esm/objectSpread2.js", + "./helpers/objectWithoutProperties": [ + { + "node": "./helpers/objectWithoutProperties.js", + "import": "./helpers/esm/objectWithoutProperties.js", + "default": "./helpers/objectWithoutProperties.js" + }, + "./helpers/objectWithoutProperties.js" + ], + "./helpers/esm/objectWithoutProperties": "./helpers/esm/objectWithoutProperties.js", + "./helpers/objectWithoutPropertiesLoose": [ + { + "node": "./helpers/objectWithoutPropertiesLoose.js", + "import": "./helpers/esm/objectWithoutPropertiesLoose.js", + "default": "./helpers/objectWithoutPropertiesLoose.js" + }, + "./helpers/objectWithoutPropertiesLoose.js" + ], + "./helpers/esm/objectWithoutPropertiesLoose": "./helpers/esm/objectWithoutPropertiesLoose.js", + "./helpers/possibleConstructorReturn": [ + { + "node": "./helpers/possibleConstructorReturn.js", + "import": "./helpers/esm/possibleConstructorReturn.js", + "default": "./helpers/possibleConstructorReturn.js" + }, + "./helpers/possibleConstructorReturn.js" + ], + "./helpers/esm/possibleConstructorReturn": "./helpers/esm/possibleConstructorReturn.js", + "./helpers/readOnlyError": [ + { + "node": "./helpers/readOnlyError.js", + "import": "./helpers/esm/readOnlyError.js", + "default": "./helpers/readOnlyError.js" + }, + "./helpers/readOnlyError.js" + ], + "./helpers/esm/readOnlyError": "./helpers/esm/readOnlyError.js", + "./helpers/regenerator": [ + { + "node": "./helpers/regenerator.js", + "import": "./helpers/esm/regenerator.js", + "default": "./helpers/regenerator.js" + }, + "./helpers/regenerator.js" + ], + "./helpers/esm/regenerator": "./helpers/esm/regenerator.js", + "./helpers/regeneratorAsync": [ + { + "node": "./helpers/regeneratorAsync.js", + "import": "./helpers/esm/regeneratorAsync.js", + "default": "./helpers/regeneratorAsync.js" + }, + "./helpers/regeneratorAsync.js" + ], + "./helpers/esm/regeneratorAsync": "./helpers/esm/regeneratorAsync.js", + "./helpers/regeneratorAsyncGen": [ + { + "node": "./helpers/regeneratorAsyncGen.js", + "import": "./helpers/esm/regeneratorAsyncGen.js", + "default": "./helpers/regeneratorAsyncGen.js" + }, + "./helpers/regeneratorAsyncGen.js" + ], + "./helpers/esm/regeneratorAsyncGen": "./helpers/esm/regeneratorAsyncGen.js", + "./helpers/regeneratorKeys": [ + { + "node": "./helpers/regeneratorKeys.js", + "import": "./helpers/esm/regeneratorKeys.js", + "default": "./helpers/regeneratorKeys.js" + }, + "./helpers/regeneratorKeys.js" + ], + "./helpers/esm/regeneratorKeys": "./helpers/esm/regeneratorKeys.js", + "./helpers/regeneratorValues": [ + { + "node": "./helpers/regeneratorValues.js", + "import": "./helpers/esm/regeneratorValues.js", + "default": "./helpers/regeneratorValues.js" + }, + "./helpers/regeneratorValues.js" + ], + "./helpers/esm/regeneratorValues": "./helpers/esm/regeneratorValues.js", + "./helpers/set": [ + { + "node": "./helpers/set.js", + "import": "./helpers/esm/set.js", + "default": "./helpers/set.js" + }, + "./helpers/set.js" + ], + "./helpers/esm/set": "./helpers/esm/set.js", + "./helpers/setFunctionName": [ + { + "node": "./helpers/setFunctionName.js", + "import": "./helpers/esm/setFunctionName.js", + "default": "./helpers/setFunctionName.js" + }, + "./helpers/setFunctionName.js" + ], + "./helpers/esm/setFunctionName": "./helpers/esm/setFunctionName.js", + "./helpers/setPrototypeOf": [ + { + "node": "./helpers/setPrototypeOf.js", + "import": "./helpers/esm/setPrototypeOf.js", + "default": "./helpers/setPrototypeOf.js" + }, + "./helpers/setPrototypeOf.js" + ], + "./helpers/esm/setPrototypeOf": "./helpers/esm/setPrototypeOf.js", + "./helpers/skipFirstGeneratorNext": [ + { + "node": "./helpers/skipFirstGeneratorNext.js", + "import": "./helpers/esm/skipFirstGeneratorNext.js", + "default": "./helpers/skipFirstGeneratorNext.js" + }, + "./helpers/skipFirstGeneratorNext.js" + ], + "./helpers/esm/skipFirstGeneratorNext": "./helpers/esm/skipFirstGeneratorNext.js", + "./helpers/slicedToArray": [ + { + "node": "./helpers/slicedToArray.js", + "import": "./helpers/esm/slicedToArray.js", + "default": "./helpers/slicedToArray.js" + }, + "./helpers/slicedToArray.js" + ], + "./helpers/esm/slicedToArray": "./helpers/esm/slicedToArray.js", + "./helpers/superPropBase": [ + { + "node": "./helpers/superPropBase.js", + "import": "./helpers/esm/superPropBase.js", + "default": "./helpers/superPropBase.js" + }, + "./helpers/superPropBase.js" + ], + "./helpers/esm/superPropBase": "./helpers/esm/superPropBase.js", + "./helpers/superPropGet": [ + { + "node": "./helpers/superPropGet.js", + "import": "./helpers/esm/superPropGet.js", + "default": "./helpers/superPropGet.js" + }, + "./helpers/superPropGet.js" + ], + "./helpers/esm/superPropGet": "./helpers/esm/superPropGet.js", + "./helpers/superPropSet": [ + { + "node": "./helpers/superPropSet.js", + "import": "./helpers/esm/superPropSet.js", + "default": "./helpers/superPropSet.js" + }, + "./helpers/superPropSet.js" + ], + "./helpers/esm/superPropSet": "./helpers/esm/superPropSet.js", + "./helpers/taggedTemplateLiteral": [ + { + "node": "./helpers/taggedTemplateLiteral.js", + "import": "./helpers/esm/taggedTemplateLiteral.js", + "default": "./helpers/taggedTemplateLiteral.js" + }, + "./helpers/taggedTemplateLiteral.js" + ], + "./helpers/esm/taggedTemplateLiteral": "./helpers/esm/taggedTemplateLiteral.js", + "./helpers/taggedTemplateLiteralLoose": [ + { + "node": "./helpers/taggedTemplateLiteralLoose.js", + "import": "./helpers/esm/taggedTemplateLiteralLoose.js", + "default": "./helpers/taggedTemplateLiteralLoose.js" + }, + "./helpers/taggedTemplateLiteralLoose.js" + ], + "./helpers/esm/taggedTemplateLiteralLoose": "./helpers/esm/taggedTemplateLiteralLoose.js", + "./helpers/tdz": [ + { + "node": "./helpers/tdz.js", + "import": "./helpers/esm/tdz.js", + "default": "./helpers/tdz.js" + }, + "./helpers/tdz.js" + ], + "./helpers/esm/tdz": "./helpers/esm/tdz.js", + "./helpers/temporalRef": [ + { + "node": "./helpers/temporalRef.js", + "import": "./helpers/esm/temporalRef.js", + "default": "./helpers/temporalRef.js" + }, + "./helpers/temporalRef.js" + ], + "./helpers/esm/temporalRef": "./helpers/esm/temporalRef.js", + "./helpers/temporalUndefined": [ + { + "node": "./helpers/temporalUndefined.js", + "import": "./helpers/esm/temporalUndefined.js", + "default": "./helpers/temporalUndefined.js" + }, + "./helpers/temporalUndefined.js" + ], + "./helpers/esm/temporalUndefined": "./helpers/esm/temporalUndefined.js", + "./helpers/toArray": [ + { + "node": "./helpers/toArray.js", + "import": "./helpers/esm/toArray.js", + "default": "./helpers/toArray.js" + }, + "./helpers/toArray.js" + ], + "./helpers/esm/toArray": "./helpers/esm/toArray.js", + "./helpers/toConsumableArray": [ + { + "node": "./helpers/toConsumableArray.js", + "import": "./helpers/esm/toConsumableArray.js", + "default": "./helpers/toConsumableArray.js" + }, + "./helpers/toConsumableArray.js" + ], + "./helpers/esm/toConsumableArray": "./helpers/esm/toConsumableArray.js", + "./helpers/toPrimitive": [ + { + "node": "./helpers/toPrimitive.js", + "import": "./helpers/esm/toPrimitive.js", + "default": "./helpers/toPrimitive.js" + }, + "./helpers/toPrimitive.js" + ], + "./helpers/esm/toPrimitive": "./helpers/esm/toPrimitive.js", + "./helpers/toPropertyKey": [ + { + "node": "./helpers/toPropertyKey.js", + "import": "./helpers/esm/toPropertyKey.js", + "default": "./helpers/toPropertyKey.js" + }, + "./helpers/toPropertyKey.js" + ], + "./helpers/esm/toPropertyKey": "./helpers/esm/toPropertyKey.js", + "./helpers/toSetter": [ + { + "node": "./helpers/toSetter.js", + "import": "./helpers/esm/toSetter.js", + "default": "./helpers/toSetter.js" + }, + "./helpers/toSetter.js" + ], + "./helpers/esm/toSetter": "./helpers/esm/toSetter.js", + "./helpers/tsRewriteRelativeImportExtensions": [ + { + "node": "./helpers/tsRewriteRelativeImportExtensions.js", + "import": "./helpers/esm/tsRewriteRelativeImportExtensions.js", + "default": "./helpers/tsRewriteRelativeImportExtensions.js" + }, + "./helpers/tsRewriteRelativeImportExtensions.js" + ], + "./helpers/esm/tsRewriteRelativeImportExtensions": "./helpers/esm/tsRewriteRelativeImportExtensions.js", + "./helpers/typeof": [ + { + "node": "./helpers/typeof.js", + "import": "./helpers/esm/typeof.js", + "default": "./helpers/typeof.js" + }, + "./helpers/typeof.js" + ], + "./helpers/esm/typeof": "./helpers/esm/typeof.js", + "./helpers/unsupportedIterableToArray": [ + { + "node": "./helpers/unsupportedIterableToArray.js", + "import": "./helpers/esm/unsupportedIterableToArray.js", + "default": "./helpers/unsupportedIterableToArray.js" + }, + "./helpers/unsupportedIterableToArray.js" + ], + "./helpers/esm/unsupportedIterableToArray": "./helpers/esm/unsupportedIterableToArray.js", + "./helpers/usingCtx": [ + { + "node": "./helpers/usingCtx.js", + "import": "./helpers/esm/usingCtx.js", + "default": "./helpers/usingCtx.js" + }, + "./helpers/usingCtx.js" + ], + "./helpers/esm/usingCtx": "./helpers/esm/usingCtx.js", + "./helpers/wrapAsyncGenerator": [ + { + "node": "./helpers/wrapAsyncGenerator.js", + "import": "./helpers/esm/wrapAsyncGenerator.js", + "default": "./helpers/wrapAsyncGenerator.js" + }, + "./helpers/wrapAsyncGenerator.js" + ], + "./helpers/esm/wrapAsyncGenerator": "./helpers/esm/wrapAsyncGenerator.js", + "./helpers/wrapNativeSuper": [ + { + "node": "./helpers/wrapNativeSuper.js", + "import": "./helpers/esm/wrapNativeSuper.js", + "default": "./helpers/wrapNativeSuper.js" + }, + "./helpers/wrapNativeSuper.js" + ], + "./helpers/esm/wrapNativeSuper": "./helpers/esm/wrapNativeSuper.js", + "./helpers/wrapRegExp": [ + { + "node": "./helpers/wrapRegExp.js", + "import": "./helpers/esm/wrapRegExp.js", + "default": "./helpers/wrapRegExp.js" + }, + "./helpers/wrapRegExp.js" + ], + "./helpers/esm/wrapRegExp": "./helpers/esm/wrapRegExp.js", + "./helpers/writeOnlyError": [ + { + "node": "./helpers/writeOnlyError.js", + "import": "./helpers/esm/writeOnlyError.js", + "default": "./helpers/writeOnlyError.js" + }, + "./helpers/writeOnlyError.js" + ], + "./helpers/esm/writeOnlyError": "./helpers/esm/writeOnlyError.js", + "./helpers/AwaitValue": [ + { + "node": "./helpers/AwaitValue.js", + "import": "./helpers/esm/AwaitValue.js", + "default": "./helpers/AwaitValue.js" + }, + "./helpers/AwaitValue.js" + ], + "./helpers/esm/AwaitValue": "./helpers/esm/AwaitValue.js", + "./helpers/applyDecs": [ + { + "node": "./helpers/applyDecs.js", + "import": "./helpers/esm/applyDecs.js", + "default": "./helpers/applyDecs.js" + }, + "./helpers/applyDecs.js" + ], + "./helpers/esm/applyDecs": "./helpers/esm/applyDecs.js", + "./helpers/applyDecs2203": [ + { + "node": "./helpers/applyDecs2203.js", + "import": "./helpers/esm/applyDecs2203.js", + "default": "./helpers/applyDecs2203.js" + }, + "./helpers/applyDecs2203.js" + ], + "./helpers/esm/applyDecs2203": "./helpers/esm/applyDecs2203.js", + "./helpers/applyDecs2203R": [ + { + "node": "./helpers/applyDecs2203R.js", + "import": "./helpers/esm/applyDecs2203R.js", + "default": "./helpers/applyDecs2203R.js" + }, + "./helpers/applyDecs2203R.js" + ], + "./helpers/esm/applyDecs2203R": "./helpers/esm/applyDecs2203R.js", + "./helpers/applyDecs2301": [ + { + "node": "./helpers/applyDecs2301.js", + "import": "./helpers/esm/applyDecs2301.js", + "default": "./helpers/applyDecs2301.js" + }, + "./helpers/applyDecs2301.js" + ], + "./helpers/esm/applyDecs2301": "./helpers/esm/applyDecs2301.js", + "./helpers/applyDecs2305": [ + { + "node": "./helpers/applyDecs2305.js", + "import": "./helpers/esm/applyDecs2305.js", + "default": "./helpers/applyDecs2305.js" + }, + "./helpers/applyDecs2305.js" + ], + "./helpers/esm/applyDecs2305": "./helpers/esm/applyDecs2305.js", + "./helpers/classApplyDescriptorDestructureSet": [ + { + "node": "./helpers/classApplyDescriptorDestructureSet.js", + "import": "./helpers/esm/classApplyDescriptorDestructureSet.js", + "default": "./helpers/classApplyDescriptorDestructureSet.js" + }, + "./helpers/classApplyDescriptorDestructureSet.js" + ], + "./helpers/esm/classApplyDescriptorDestructureSet": "./helpers/esm/classApplyDescriptorDestructureSet.js", + "./helpers/classApplyDescriptorGet": [ + { + "node": "./helpers/classApplyDescriptorGet.js", + "import": "./helpers/esm/classApplyDescriptorGet.js", + "default": "./helpers/classApplyDescriptorGet.js" + }, + "./helpers/classApplyDescriptorGet.js" + ], + "./helpers/esm/classApplyDescriptorGet": "./helpers/esm/classApplyDescriptorGet.js", + "./helpers/classApplyDescriptorSet": [ + { + "node": "./helpers/classApplyDescriptorSet.js", + "import": "./helpers/esm/classApplyDescriptorSet.js", + "default": "./helpers/classApplyDescriptorSet.js" + }, + "./helpers/classApplyDescriptorSet.js" + ], + "./helpers/esm/classApplyDescriptorSet": "./helpers/esm/classApplyDescriptorSet.js", + "./helpers/classCheckPrivateStaticAccess": [ + { + "node": "./helpers/classCheckPrivateStaticAccess.js", + "import": "./helpers/esm/classCheckPrivateStaticAccess.js", + "default": "./helpers/classCheckPrivateStaticAccess.js" + }, + "./helpers/classCheckPrivateStaticAccess.js" + ], + "./helpers/esm/classCheckPrivateStaticAccess": "./helpers/esm/classCheckPrivateStaticAccess.js", + "./helpers/classCheckPrivateStaticFieldDescriptor": [ + { + "node": "./helpers/classCheckPrivateStaticFieldDescriptor.js", + "import": "./helpers/esm/classCheckPrivateStaticFieldDescriptor.js", + "default": "./helpers/classCheckPrivateStaticFieldDescriptor.js" + }, + "./helpers/classCheckPrivateStaticFieldDescriptor.js" + ], + "./helpers/esm/classCheckPrivateStaticFieldDescriptor": "./helpers/esm/classCheckPrivateStaticFieldDescriptor.js", + "./helpers/classExtractFieldDescriptor": [ + { + "node": "./helpers/classExtractFieldDescriptor.js", + "import": "./helpers/esm/classExtractFieldDescriptor.js", + "default": "./helpers/classExtractFieldDescriptor.js" + }, + "./helpers/classExtractFieldDescriptor.js" + ], + "./helpers/esm/classExtractFieldDescriptor": "./helpers/esm/classExtractFieldDescriptor.js", + "./helpers/classPrivateFieldDestructureSet": [ + { + "node": "./helpers/classPrivateFieldDestructureSet.js", + "import": "./helpers/esm/classPrivateFieldDestructureSet.js", + "default": "./helpers/classPrivateFieldDestructureSet.js" + }, + "./helpers/classPrivateFieldDestructureSet.js" + ], + "./helpers/esm/classPrivateFieldDestructureSet": "./helpers/esm/classPrivateFieldDestructureSet.js", + "./helpers/classPrivateFieldGet": [ + { + "node": "./helpers/classPrivateFieldGet.js", + "import": "./helpers/esm/classPrivateFieldGet.js", + "default": "./helpers/classPrivateFieldGet.js" + }, + "./helpers/classPrivateFieldGet.js" + ], + "./helpers/esm/classPrivateFieldGet": "./helpers/esm/classPrivateFieldGet.js", + "./helpers/classPrivateFieldSet": [ + { + "node": "./helpers/classPrivateFieldSet.js", + "import": "./helpers/esm/classPrivateFieldSet.js", + "default": "./helpers/classPrivateFieldSet.js" + }, + "./helpers/classPrivateFieldSet.js" + ], + "./helpers/esm/classPrivateFieldSet": "./helpers/esm/classPrivateFieldSet.js", + "./helpers/classPrivateMethodGet": [ + { + "node": "./helpers/classPrivateMethodGet.js", + "import": "./helpers/esm/classPrivateMethodGet.js", + "default": "./helpers/classPrivateMethodGet.js" + }, + "./helpers/classPrivateMethodGet.js" + ], + "./helpers/esm/classPrivateMethodGet": "./helpers/esm/classPrivateMethodGet.js", + "./helpers/classPrivateMethodSet": [ + { + "node": "./helpers/classPrivateMethodSet.js", + "import": "./helpers/esm/classPrivateMethodSet.js", + "default": "./helpers/classPrivateMethodSet.js" + }, + "./helpers/classPrivateMethodSet.js" + ], + "./helpers/esm/classPrivateMethodSet": "./helpers/esm/classPrivateMethodSet.js", + "./helpers/classStaticPrivateFieldDestructureSet": [ + { + "node": "./helpers/classStaticPrivateFieldDestructureSet.js", + "import": "./helpers/esm/classStaticPrivateFieldDestructureSet.js", + "default": "./helpers/classStaticPrivateFieldDestructureSet.js" + }, + "./helpers/classStaticPrivateFieldDestructureSet.js" + ], + "./helpers/esm/classStaticPrivateFieldDestructureSet": "./helpers/esm/classStaticPrivateFieldDestructureSet.js", + "./helpers/classStaticPrivateFieldSpecGet": [ + { + "node": "./helpers/classStaticPrivateFieldSpecGet.js", + "import": "./helpers/esm/classStaticPrivateFieldSpecGet.js", + "default": "./helpers/classStaticPrivateFieldSpecGet.js" + }, + "./helpers/classStaticPrivateFieldSpecGet.js" + ], + "./helpers/esm/classStaticPrivateFieldSpecGet": "./helpers/esm/classStaticPrivateFieldSpecGet.js", + "./helpers/classStaticPrivateFieldSpecSet": [ + { + "node": "./helpers/classStaticPrivateFieldSpecSet.js", + "import": "./helpers/esm/classStaticPrivateFieldSpecSet.js", + "default": "./helpers/classStaticPrivateFieldSpecSet.js" + }, + "./helpers/classStaticPrivateFieldSpecSet.js" + ], + "./helpers/esm/classStaticPrivateFieldSpecSet": "./helpers/esm/classStaticPrivateFieldSpecSet.js", + "./helpers/classStaticPrivateMethodSet": [ + { + "node": "./helpers/classStaticPrivateMethodSet.js", + "import": "./helpers/esm/classStaticPrivateMethodSet.js", + "default": "./helpers/classStaticPrivateMethodSet.js" + }, + "./helpers/classStaticPrivateMethodSet.js" + ], + "./helpers/esm/classStaticPrivateMethodSet": "./helpers/esm/classStaticPrivateMethodSet.js", + "./helpers/defineEnumerableProperties": [ + { + "node": "./helpers/defineEnumerableProperties.js", + "import": "./helpers/esm/defineEnumerableProperties.js", + "default": "./helpers/defineEnumerableProperties.js" + }, + "./helpers/defineEnumerableProperties.js" + ], + "./helpers/esm/defineEnumerableProperties": "./helpers/esm/defineEnumerableProperties.js", + "./helpers/dispose": [ + { + "node": "./helpers/dispose.js", + "import": "./helpers/esm/dispose.js", + "default": "./helpers/dispose.js" + }, + "./helpers/dispose.js" + ], + "./helpers/esm/dispose": "./helpers/esm/dispose.js", + "./helpers/objectSpread": [ + { + "node": "./helpers/objectSpread.js", + "import": "./helpers/esm/objectSpread.js", + "default": "./helpers/objectSpread.js" + }, + "./helpers/objectSpread.js" + ], + "./helpers/esm/objectSpread": "./helpers/esm/objectSpread.js", + "./helpers/regeneratorRuntime": [ + { + "node": "./helpers/regeneratorRuntime.js", + "import": "./helpers/esm/regeneratorRuntime.js", + "default": "./helpers/regeneratorRuntime.js" + }, + "./helpers/regeneratorRuntime.js" + ], + "./helpers/esm/regeneratorRuntime": "./helpers/esm/regeneratorRuntime.js", + "./helpers/using": [ + { + "node": "./helpers/using.js", + "import": "./helpers/esm/using.js", + "default": "./helpers/using.js" + }, + "./helpers/using.js" + ], + "./helpers/esm/using": "./helpers/esm/using.js", + "./package": "./package.json", + "./package.json": "./package.json", + "./regenerator": "./regenerator/index.js", + "./regenerator/*.js": "./regenerator/*.js", + "./regenerator/": "./regenerator/" + }, + "engines": { + "node": ">=6.9.0" + }, + "type": "commonjs" +} \ No newline at end of file diff --git a/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/regenerator/index.js b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/regenerator/index.js new file mode 100644 index 0000000000000000000000000000000000000000..5881357364f41aea98c1c01ab2b9056adc79689f --- /dev/null +++ b/node_modules/.pnpm/@babel+runtime@7.28.2/node_modules/@babel/runtime/regenerator/index.js @@ -0,0 +1,15 @@ +// TODO(Babel 8): Remove this file. + +var runtime = require("../helpers/regeneratorRuntime")(); +module.exports = runtime; + +// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736= +try { + regeneratorRuntime = runtime; +} catch (accidentalStrictMode) { + if (typeof globalThis === "object") { + globalThis.regeneratorRuntime = runtime; + } else { + Function("r", "regeneratorRuntime = r")(runtime); + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/README.md b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/README.md new file mode 100644 index 0000000000000000000000000000000000000000..52883a3eba88bb302854536a75af223771710166 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/README.md @@ -0,0 +1,44 @@ +# @bufbuild/protobuf + +This package provides the runtime library for the [protoc-gen-es](https://www.npmjs.com/package/@bufbuild/protoc-gen-es) +code generator plugin. + +## Protocol Buffers for ECMAScript + +A complete implementation of [Protocol Buffers](https://protobuf.dev/) in TypeScript, +suitable for web browsers and Node.js, created by [Buf](https://buf.build). + +**Protobuf-ES** is a solid, modern alternative to existing Protobuf implementations for the JavaScript ecosystem. It's +the first project in this space to provide a comprehensive plugin framework and decouple the base types from RPC +functionality. + +Some additional features that set it apart from the others: + +- ECMAScript module support +- First-class TypeScript support +- Generation of idiomatic JavaScript and TypeScript code +- Generation of [much smaller bundles](https://github.com/bufbuild/protobuf-es/tree/main/packages/bundle-size/) +- Implementation of all proto3 features, including the [canonical JSON format](https://protobuf.dev/programming-guides/proto3/#json) +- Implementation of all proto2 features, except for extensions and the text format +- Usage of standard JavaScript APIs instead of the [Closure Library](http://googlecode.blogspot.com/2009/11/introducing-closure-tools.html) +- Compatibility is covered by the Protocol Buffers [conformance tests](https://github.com/bufbuild/protobuf-es/tree/main/packages/protobuf-conformance/) +- Descriptor and reflection support + +## Installation + +```bash +npm install @bufbuild/protobuf +``` + +## Documentation + +To learn how to work with `@bufbuild/protobuf`, check out the docs for the [Runtime API](https://github.com/bufbuild/protobuf-es/tree/main/MANUAL.md#working-with-messages) +and the [generated code](https://github.com/bufbuild/protobuf-es/tree/main/MANUAL.md#generated-code). + +Official documentation for the Protobuf-ES project can be found at [github.com/bufbuild/protobuf-es](https://github.com/bufbuild/protobuf-es). + +For more information on Buf, check out the official [Buf documentation](https://buf.build/docs/). + +## Examples + +A complete code example can be found in the **Protobuf-ES** repo [here](https://github.com/bufbuild/protobuf-es/tree/main/packages/protobuf-example). diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/clone.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/clone.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1bb50b69734ac61a48a364f40cfb0c598443ae1c --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/clone.d.ts @@ -0,0 +1,6 @@ +import type { MessageShape } from "./types.js"; +import { type DescMessage } from "./descriptors.js"; +/** + * Create a deep copy of a message, including extensions and unknown fields. + */ +export declare function clone(schema: Desc, message: MessageShape): MessageShape; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/clone.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/clone.js new file mode 100644 index 0000000000000000000000000000000000000000..d263859db44904173ac65803ed839bd40f7c742a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/clone.js @@ -0,0 +1,66 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.clone = clone; +const descriptors_js_1 = require("./descriptors.js"); +const reflect_js_1 = require("./reflect/reflect.js"); +const guard_js_1 = require("./reflect/guard.js"); +/** + * Create a deep copy of a message, including extensions and unknown fields. + */ +function clone(schema, message) { + return cloneReflect((0, reflect_js_1.reflect)(schema, message)).message; +} +function cloneReflect(i) { + const o = (0, reflect_js_1.reflect)(i.desc); + for (const f of i.fields) { + if (!i.isSet(f)) { + continue; + } + switch (f.fieldKind) { + case "list": + const list = o.get(f); + for (const item of i.get(f)) { + list.add(cloneSingular(f, item)); + } + break; + case "map": + const map = o.get(f); + for (const entry of i.get(f).entries()) { + map.set(entry[0], cloneSingular(f, entry[1])); + } + break; + default: { + o.set(f, cloneSingular(f, i.get(f))); + break; + } + } + } + const unknown = i.getUnknown(); + if (unknown && unknown.length > 0) { + o.setUnknown([...unknown]); + } + return o; +} +function cloneSingular(field, value) { + if (field.message !== undefined && (0, guard_js_1.isReflectMessage)(value)) { + return cloneReflect(value); + } + if (field.scalar == descriptors_js_1.ScalarType.BYTES && value instanceof Uint8Array) { + // @ts-expect-error T cannot extend Uint8Array in practice + return value.slice(); + } + return value; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/enum.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/enum.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8f5c83a3180972742186b1cb625525c1d051e3ae --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/enum.d.ts @@ -0,0 +1,10 @@ +import type { DescFile } from "../descriptors.js"; +import type { GenEnum } from "./types.js"; +import type { JsonValue } from "../json-value.js"; +export { tsEnum } from "../codegenv2/enum.js"; +/** + * Hydrate an enum descriptor. + * + * @private + */ +export declare function enumDesc(file: DescFile, path: number, ...paths: number[]): GenEnum; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/enum.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/enum.js new file mode 100644 index 0000000000000000000000000000000000000000..853ae9f65212631eb75eee0302b6507d9ccd5960 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/enum.js @@ -0,0 +1,31 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.tsEnum = void 0; +exports.enumDesc = enumDesc; +var enum_js_1 = require("../codegenv2/enum.js"); +Object.defineProperty(exports, "tsEnum", { enumerable: true, get: function () { return enum_js_1.tsEnum; } }); +/** + * Hydrate an enum descriptor. + * + * @private + */ +function enumDesc(file, path, ...paths) { + if (paths.length == 0) { + return file.enums[path]; + } + const e = paths.pop(); // we checked length above + return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]).nestedEnums[e]; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/extension.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/extension.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7d6374bcec186a977ddacd246b40d85b3eff055b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/extension.d.ts @@ -0,0 +1,9 @@ +import type { Message } from "../types.js"; +import type { DescFile } from "../descriptors.js"; +import type { GenExtension } from "./types.js"; +/** + * Hydrate an extension descriptor. + * + * @private + */ +export declare function extDesc(file: DescFile, path: number, ...paths: number[]): GenExtension; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/extension.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/extension.js new file mode 100644 index 0000000000000000000000000000000000000000..9d4947a41dbe98f92122edb89a72e40b226ab1d8 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/extension.js @@ -0,0 +1,28 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.extDesc = extDesc; +/** + * Hydrate an extension descriptor. + * + * @private + */ +function extDesc(file, path, ...paths) { + if (paths.length == 0) { + return file.extensions[path]; + } + const e = paths.pop(); // we checked length above + return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]).nestedExtensions[e]; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/file.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/file.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5c3a5130ba3660c6e1d60292a17fb9a2b1036e23 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/file.d.ts @@ -0,0 +1 @@ +export { fileDesc } from "../codegenv2/file.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/file.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/file.js new file mode 100644 index 0000000000000000000000000000000000000000..b007f3119b23c511b87d831efa4f59a35d936cd1 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/file.js @@ -0,0 +1,18 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.fileDesc = void 0; +var file_js_1 = require("../codegenv2/file.js"); +Object.defineProperty(exports, "fileDesc", { enumerable: true, get: function () { return file_js_1.fileDesc; } }); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/index.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a3f2ade756d461c31c5241dda3f62d2974f2a39c --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/index.d.ts @@ -0,0 +1,10 @@ +export * from "../codegenv2/boot.js"; +export * from "../codegenv2/embed.js"; +export * from "./enum.js"; +export * from "./extension.js"; +export * from "./file.js"; +export * from "./message.js"; +export * from "./service.js"; +export * from "./symbols.js"; +export * from "../codegenv2/scalar.js"; +export * from "./types.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/index.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/index.js new file mode 100644 index 0000000000000000000000000000000000000000..1680a977040c2cc26aac118e2e6492ceb60ce4a6 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/index.js @@ -0,0 +1,39 @@ +"use strict"; +// Copyright 2021-2025 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. +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("../codegenv2/boot.js"), exports); +__exportStar(require("../codegenv2/embed.js"), exports); +__exportStar(require("./enum.js"), exports); +__exportStar(require("./extension.js"), exports); +__exportStar(require("./file.js"), exports); +__exportStar(require("./message.js"), exports); +__exportStar(require("./service.js"), exports); +__exportStar(require("./symbols.js"), exports); +__exportStar(require("../codegenv2/scalar.js"), exports); +__exportStar(require("./types.js"), exports); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/message.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/message.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..46ad4ad1ce7d510cfcf5b28dfd8b26563bc7d6e2 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/message.d.ts @@ -0,0 +1,10 @@ +import type { Message } from "../types.js"; +import type { DescFile } from "../descriptors.js"; +import type { GenMessage } from "./types.js"; +import type { JsonValue } from "../json-value.js"; +/** + * Hydrate a message descriptor. + * + * @private + */ +export declare function messageDesc(file: DescFile, path: number, ...paths: number[]): GenMessage; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/message.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/message.js new file mode 100644 index 0000000000000000000000000000000000000000..e7219edde6e9cc68057c4a4e20dc1ae16e5f71bc --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/message.js @@ -0,0 +1,24 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.messageDesc = messageDesc; +/** + * Hydrate a message descriptor. + * + * @private + */ +function messageDesc(file, path, ...paths) { + return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/service.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/service.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5818f75d547bf0b73e1da8d26ffb7e3f48bfa3f3 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/service.d.ts @@ -0,0 +1,8 @@ +import type { GenService, GenServiceMethods } from "./types.js"; +import type { DescFile } from "../descriptors.js"; +/** + * Hydrate a service descriptor. + * + * @private + */ +export declare function serviceDesc(file: DescFile, path: number, ...paths: number[]): GenService; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/service.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/service.js new file mode 100644 index 0000000000000000000000000000000000000000..8fb7f8b746b20aab0b88cd1611946c196dcc4ab1 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/service.js @@ -0,0 +1,27 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.serviceDesc = serviceDesc; +/** + * Hydrate a service descriptor. + * + * @private + */ +function serviceDesc(file, path, ...paths) { + if (paths.length > 0) { + throw new Error(); + } + return file.services[path]; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/symbols.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/symbols.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..fb9fd70ebddb4bafa7cca7e3479564ababb5db3a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/symbols.d.ts @@ -0,0 +1,135 @@ +/** + * @private + */ +export declare const packageName = "@bufbuild/protobuf"; +/** + * @private + */ +export declare const wktPublicImportPaths: Readonly>; +/** + * @private + */ +export declare const symbols: { + readonly codegen: { + readonly boot: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv1/boot.js"; + readonly from: string; + }; + readonly fileDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv1/file.js"; + readonly from: string; + }; + readonly enumDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv1/enum.js"; + readonly from: string; + }; + readonly extDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv1/extension.js"; + readonly from: string; + }; + readonly messageDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv1/message.js"; + readonly from: string; + }; + readonly serviceDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv1/service.js"; + readonly from: string; + }; + readonly tsEnum: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv1/enum.js"; + readonly from: string; + }; + readonly GenFile: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv1/types.js"; + readonly from: string; + }; + readonly GenEnum: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv1/types.js"; + readonly from: string; + }; + readonly GenExtension: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv1/types.js"; + readonly from: string; + }; + readonly GenMessage: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv1/types.js"; + readonly from: string; + }; + readonly GenService: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv1/types.js"; + readonly from: string; + }; + }; + readonly isMessage: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../is-message.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly Message: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../types.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly create: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../create.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly fromJson: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../from-json.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly fromJsonString: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../from-json.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly fromBinary: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../from-binary.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly toBinary: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../to-binary.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly toJson: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../to-json.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly toJsonString: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../to-json.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly protoInt64: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../proto-int64.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly JsonValue: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../json-value.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly JsonObject: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../json-value.js"; + readonly from: "@bufbuild/protobuf"; + }; +}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/symbols.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/symbols.js new file mode 100644 index 0000000000000000000000000000000000000000..6491cc32619f80884c52cdb87c2b9a5593fa8e61 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/symbols.js @@ -0,0 +1,43 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.symbols = exports.wktPublicImportPaths = exports.packageName = void 0; +const symbols_js_1 = require("../codegenv2/symbols.js"); +/** + * @private + */ +exports.packageName = symbols_js_1.packageName; +/** + * @private + */ +exports.wktPublicImportPaths = symbols_js_1.wktPublicImportPaths; +/** + * @private + */ +// biome-ignore format: want this to read well +exports.symbols = Object.assign(Object.assign({}, symbols_js_1.symbols), { codegen: { + boot: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/boot.js", from: exports.packageName + "/codegenv1" }, + fileDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/file.js", from: exports.packageName + "/codegenv1" }, + enumDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/enum.js", from: exports.packageName + "/codegenv1" }, + extDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/extension.js", from: exports.packageName + "/codegenv1" }, + messageDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/message.js", from: exports.packageName + "/codegenv1" }, + serviceDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/service.js", from: exports.packageName + "/codegenv1" }, + tsEnum: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/enum.js", from: exports.packageName + "/codegenv1" }, + GenFile: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: exports.packageName + "/codegenv1" }, + GenEnum: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: exports.packageName + "/codegenv1" }, + GenExtension: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: exports.packageName + "/codegenv1" }, + GenMessage: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: exports.packageName + "/codegenv1" }, + GenService: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: exports.packageName + "/codegenv1" }, + } }); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/types.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/types.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8060fade67e8af9aa0f08e45322149a13e9a7d31 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/types.d.ts @@ -0,0 +1,75 @@ +import type { Message } from "../types.js"; +import type { DescEnum, DescEnumValue, DescExtension, DescField, DescFile, DescMessage, DescMethod, DescService } from "../descriptors.js"; +import type { JsonValue } from "../json-value.js"; +/** + * Describes a protobuf source file. + * + * @private + */ +export type GenFile = DescFile; +/** + * Describes a message declaration in a protobuf source file. + * + * This type is identical to DescMessage, but carries additional type + * information. + * + * @private + */ +export type GenMessage = Omit & { + field: Record, DescField>; + typeName: RuntimeShape["$typeName"]; +} & brandv1; +/** + * Describes an enumeration in a protobuf source file. + * + * This type is identical to DescEnum, but carries additional type + * information. + * + * @private + */ +export type GenEnum = Omit & { + value: Record; +} & brandv1; +/** + * Describes an extension in a protobuf source file. + * + * This type is identical to DescExtension, but carries additional type + * information. + * + * @private + */ +export type GenExtension = DescExtension & brandv1; +/** + * Describes a service declaration in a protobuf source file. + * + * This type is identical to DescService, but carries additional type + * information. + * + * @private + */ +export type GenService = Omit & { + method: { + [K in keyof RuntimeShape]: RuntimeShape[K] & DescMethod; + }; +}; +/** + * @private + */ +export type GenServiceMethods = Record>; +declare class brandv1 { + protected v: "codegenv1"; + protected a: A | boolean; + protected b: B | boolean; +} +/** + * Union of the property names of all fields, including oneof members. + * For an anonymous message (no generated message shape), it's simply a string. + */ +type MessageFieldNames = Message extends T ? string : Exclude ? K : P]-?: true; +}, number | symbol>; +type Oneof = { + case: K | undefined; + value?: unknown; +}; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/types.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/types.js new file mode 100644 index 0000000000000000000000000000000000000000..2972b993c589fe770f42989b9a4875c117195f0a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv1/types.js @@ -0,0 +1,22 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +class brandv1 { + constructor() { + this.v = "codegenv1"; + this.a = false; + this.b = false; + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/boot.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/boot.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3edbb6c59bb896576a37c27a11a1f2882b902aa4 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/boot.d.ts @@ -0,0 +1,63 @@ +import type { DescriptorProto_ExtensionRange, FieldDescriptorProto_Label, FieldDescriptorProto_Type, FieldOptions_OptionRetention, FieldOptions_OptionTargetType, FieldOptions_EditionDefault, EnumValueDescriptorProto, FileDescriptorProto } from "../wkt/gen/google/protobuf/descriptor_pb.js"; +import type { DescFile } from "../descriptors.js"; +/** + * Hydrate a file descriptor for google/protobuf/descriptor.proto from a plain + * object. + * + * See createFileDescriptorProtoBoot() for details. + * + * @private + */ +export declare function boot(boot: FileDescriptorProtoBoot): DescFile; +/** + * An object literal for initializing the message google.protobuf.FileDescriptorProto + * for google/protobuf/descriptor.proto. + * + * See createFileDescriptorProtoBoot() for details. + * + * @private + */ +export type FileDescriptorProtoBoot = { + name: "google/protobuf/descriptor.proto"; + package: "google.protobuf"; + messageType: DescriptorProtoBoot[]; + enumType: EnumDescriptorProtoBoot[]; +}; +export type DescriptorProtoBoot = { + name: string; + field?: FieldDescriptorProtoBoot[]; + nestedType?: DescriptorProtoBoot[]; + enumType?: EnumDescriptorProtoBoot[]; + extensionRange?: Pick[]; +}; +export type FieldDescriptorProtoBoot = { + name: string; + number: number; + label?: FieldDescriptorProto_Label; + type: FieldDescriptorProto_Type; + typeName?: string; + extendee?: string; + defaultValue?: string; + options?: FieldOptionsBoot; +}; +export type FieldOptionsBoot = { + packed?: boolean; + deprecated?: boolean; + retention?: FieldOptions_OptionRetention; + targets?: FieldOptions_OptionTargetType[]; + editionDefaults?: FieldOptions_EditionDefaultBoot[]; +}; +export type FieldOptions_EditionDefaultBoot = Pick; +export type EnumDescriptorProtoBoot = { + name: string; + value: EnumValueDescriptorProtoBoot[]; +}; +export type EnumValueDescriptorProtoBoot = Pick; +/** + * Creates the message google.protobuf.FileDescriptorProto from an object literal. + * + * See createFileDescriptorProtoBoot() for details. + * + * @private + */ +export declare function bootFileDescriptorProto(init: FileDescriptorProtoBoot): FileDescriptorProto; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/boot.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/boot.js new file mode 100644 index 0000000000000000000000000000000000000000..23ddeede88f79cd13199f212977008152fcfd8d1 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/boot.js @@ -0,0 +1,105 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.boot = boot; +exports.bootFileDescriptorProto = bootFileDescriptorProto; +const restore_json_names_js_1 = require("./restore-json-names.js"); +const registry_js_1 = require("../registry.js"); +/** + * Hydrate a file descriptor for google/protobuf/descriptor.proto from a plain + * object. + * + * See createFileDescriptorProtoBoot() for details. + * + * @private + */ +function boot(boot) { + const root = bootFileDescriptorProto(boot); + root.messageType.forEach(restore_json_names_js_1.restoreJsonNames); + const reg = (0, registry_js_1.createFileRegistry)(root, () => undefined); + // biome-ignore lint/style/noNonNullAssertion: non-null assertion because we just created the registry from the file we look up + return reg.getFile(root.name); +} +/** + * Creates the message google.protobuf.FileDescriptorProto from an object literal. + * + * See createFileDescriptorProtoBoot() for details. + * + * @private + */ +function bootFileDescriptorProto(init) { + const proto = Object.create({ + syntax: "", + edition: 0, + }); + return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FileDescriptorProto", dependency: [], publicDependency: [], weakDependency: [], optionDependency: [], service: [], extension: [] }, init), { messageType: init.messageType.map(bootDescriptorProto), enumType: init.enumType.map(bootEnumDescriptorProto) })); +} +function bootDescriptorProto(init) { + var _a, _b, _c, _d, _e, _f, _g, _h; + const proto = Object.create({ + visibility: 0, + }); + return Object.assign(proto, { + $typeName: "google.protobuf.DescriptorProto", + name: init.name, + field: (_b = (_a = init.field) === null || _a === void 0 ? void 0 : _a.map(bootFieldDescriptorProto)) !== null && _b !== void 0 ? _b : [], + extension: [], + nestedType: (_d = (_c = init.nestedType) === null || _c === void 0 ? void 0 : _c.map(bootDescriptorProto)) !== null && _d !== void 0 ? _d : [], + enumType: (_f = (_e = init.enumType) === null || _e === void 0 ? void 0 : _e.map(bootEnumDescriptorProto)) !== null && _f !== void 0 ? _f : [], + extensionRange: (_h = (_g = init.extensionRange) === null || _g === void 0 ? void 0 : _g.map((e) => (Object.assign({ $typeName: "google.protobuf.DescriptorProto.ExtensionRange" }, e)))) !== null && _h !== void 0 ? _h : [], + oneofDecl: [], + reservedRange: [], + reservedName: [], + }); +} +function bootFieldDescriptorProto(init) { + const proto = Object.create({ + label: 1, + typeName: "", + extendee: "", + defaultValue: "", + oneofIndex: 0, + jsonName: "", + proto3Optional: false, + }); + return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FieldDescriptorProto" }, init), { options: init.options ? bootFieldOptions(init.options) : undefined })); +} +function bootFieldOptions(init) { + var _a, _b, _c; + const proto = Object.create({ + ctype: 0, + packed: false, + jstype: 0, + lazy: false, + unverifiedLazy: false, + deprecated: false, + weak: false, + debugRedact: false, + retention: 0, + }); + return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FieldOptions" }, init), { targets: (_a = init.targets) !== null && _a !== void 0 ? _a : [], editionDefaults: (_c = (_b = init.editionDefaults) === null || _b === void 0 ? void 0 : _b.map((e) => (Object.assign({ $typeName: "google.protobuf.FieldOptions.EditionDefault" }, e)))) !== null && _c !== void 0 ? _c : [], uninterpretedOption: [] })); +} +function bootEnumDescriptorProto(init) { + const proto = Object.create({ + visibility: 0, + }); + return Object.assign(proto, { + $typeName: "google.protobuf.EnumDescriptorProto", + name: init.name, + reservedName: [], + reservedRange: [], + value: init.value.map((e) => (Object.assign({ $typeName: "google.protobuf.EnumValueDescriptorProto" }, e))), + }); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/embed.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/embed.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a0feea1d86b5320d105d316e2df67777a9c7ddf9 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/embed.d.ts @@ -0,0 +1,43 @@ +import type { DescEnum, DescExtension, DescMessage, DescService } from "../descriptors.js"; +import { type FileDescriptorProto } from "../wkt/gen/google/protobuf/descriptor_pb.js"; +import type { FileDescriptorProtoBoot } from "./boot.js"; +type EmbedUnknown = { + bootable: false; + proto(): FileDescriptorProto; + base64(): string; +}; +type EmbedDescriptorProto = Omit & { + bootable: true; + boot(): FileDescriptorProtoBoot; +}; +/** + * Create necessary information to embed a file descriptor in + * generated code. + * + * @private + */ +export declare function embedFileDesc(file: FileDescriptorProto): EmbedUnknown | EmbedDescriptorProto; +/** + * Compute the path to a message, enumeration, extension, or service in a + * file descriptor. + * + * @private + */ +export declare function pathInFileDesc(desc: DescMessage | DescEnum | DescExtension | DescService): number[]; +/** + * The file descriptor for google/protobuf/descriptor.proto cannot be embedded + * in serialized form, since it is required to parse itself. + * + * This function takes an instance of the message, and returns a plain object + * that can be hydrated to the message again via bootFileDescriptorProto(). + * + * This function only works with a message google.protobuf.FileDescriptorProto + * for google/protobuf/descriptor.proto, and only supports features that are + * relevant for the specific use case. For example, it discards file options, + * reserved ranges and reserved names, and field options that are unused in + * descriptor.proto. + * + * @private + */ +export declare function createFileDescriptorProtoBoot(proto: FileDescriptorProto): FileDescriptorProtoBoot; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/embed.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/embed.js new file mode 100644 index 0000000000000000000000000000000000000000..37336dd90fca9cb7dd8c4abf8b5b9d3edb368129 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/embed.js @@ -0,0 +1,244 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.embedFileDesc = embedFileDesc; +exports.pathInFileDesc = pathInFileDesc; +exports.createFileDescriptorProtoBoot = createFileDescriptorProtoBoot; +const names_js_1 = require("../reflect/names.js"); +const fields_js_1 = require("../fields.js"); +const base64_encoding_js_1 = require("../wire/base64-encoding.js"); +const to_binary_js_1 = require("../to-binary.js"); +const clone_js_1 = require("../clone.js"); +const descriptor_pb_js_1 = require("../wkt/gen/google/protobuf/descriptor_pb.js"); +/** + * Create necessary information to embed a file descriptor in + * generated code. + * + * @private + */ +function embedFileDesc(file) { + const embed = { + bootable: false, + proto() { + const stripped = (0, clone_js_1.clone)(descriptor_pb_js_1.FileDescriptorProtoSchema, file); + (0, fields_js_1.clearField)(stripped, descriptor_pb_js_1.FileDescriptorProtoSchema.field.dependency); + (0, fields_js_1.clearField)(stripped, descriptor_pb_js_1.FileDescriptorProtoSchema.field.sourceCodeInfo); + stripped.messageType.map(stripJsonNames); + return stripped; + }, + base64() { + const bytes = (0, to_binary_js_1.toBinary)(descriptor_pb_js_1.FileDescriptorProtoSchema, this.proto()); + return (0, base64_encoding_js_1.base64Encode)(bytes, "std_raw"); + }, + }; + return file.name == "google/protobuf/descriptor.proto" + ? Object.assign(Object.assign({}, embed), { bootable: true, boot() { + return createFileDescriptorProtoBoot(this.proto()); + } }) : embed; +} +function stripJsonNames(d) { + for (const f of d.field) { + if (f.jsonName === (0, names_js_1.protoCamelCase)(f.name)) { + (0, fields_js_1.clearField)(f, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.jsonName); + } + } + for (const n of d.nestedType) { + stripJsonNames(n); + } +} +/** + * Compute the path to a message, enumeration, extension, or service in a + * file descriptor. + * + * @private + */ +function pathInFileDesc(desc) { + if (desc.kind == "service") { + return [desc.file.services.indexOf(desc)]; + } + const parent = desc.parent; + if (parent == undefined) { + switch (desc.kind) { + case "enum": + return [desc.file.enums.indexOf(desc)]; + case "message": + return [desc.file.messages.indexOf(desc)]; + case "extension": + return [desc.file.extensions.indexOf(desc)]; + } + } + function findPath(cur) { + const nested = []; + for (let parent = cur.parent; parent;) { + const idx = parent.nestedMessages.indexOf(cur); + nested.unshift(idx); + cur = parent; + parent = cur.parent; + } + nested.unshift(cur.file.messages.indexOf(cur)); + return nested; + } + const path = findPath(parent); + switch (desc.kind) { + case "extension": + return [...path, parent.nestedExtensions.indexOf(desc)]; + case "message": + return [...path, parent.nestedMessages.indexOf(desc)]; + case "enum": + return [...path, parent.nestedEnums.indexOf(desc)]; + } +} +/** + * The file descriptor for google/protobuf/descriptor.proto cannot be embedded + * in serialized form, since it is required to parse itself. + * + * This function takes an instance of the message, and returns a plain object + * that can be hydrated to the message again via bootFileDescriptorProto(). + * + * This function only works with a message google.protobuf.FileDescriptorProto + * for google/protobuf/descriptor.proto, and only supports features that are + * relevant for the specific use case. For example, it discards file options, + * reserved ranges and reserved names, and field options that are unused in + * descriptor.proto. + * + * @private + */ +function createFileDescriptorProtoBoot(proto) { + var _a; + assert(proto.name == "google/protobuf/descriptor.proto"); + assert(proto.package == "google.protobuf"); + assert(!proto.dependency.length); + assert(!proto.publicDependency.length); + assert(!proto.weakDependency.length); + assert(!proto.optionDependency.length); + assert(!proto.service.length); + assert(!proto.extension.length); + assert(proto.sourceCodeInfo === undefined); + assert(proto.syntax == "" || proto.syntax == "proto2"); + assert(!((_a = proto.options) === null || _a === void 0 ? void 0 : _a.features)); // we're dropping file options + assert(proto.edition === descriptor_pb_js_1.Edition.EDITION_UNKNOWN); + return { + name: proto.name, + package: proto.package, + messageType: proto.messageType.map(createDescriptorBoot), + enumType: proto.enumType.map(createEnumDescriptorBoot), + }; +} +function createDescriptorBoot(proto) { + assert(proto.extension.length == 0); + assert(!proto.oneofDecl.length); + assert(!proto.options); + assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.DescriptorProtoSchema.field.visibility)); + const b = { + name: proto.name, + }; + if (proto.field.length) { + b.field = proto.field.map(createFieldDescriptorBoot); + } + if (proto.nestedType.length) { + b.nestedType = proto.nestedType.map(createDescriptorBoot); + } + if (proto.enumType.length) { + b.enumType = proto.enumType.map(createEnumDescriptorBoot); + } + if (proto.extensionRange.length) { + b.extensionRange = proto.extensionRange.map((r) => { + assert(!r.options); + return { start: r.start, end: r.end }; + }); + } + return b; +} +function createFieldDescriptorBoot(proto) { + assert((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.name)); + assert((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.number)); + assert((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.type)); + assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.oneofIndex)); + assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.jsonName) || + proto.jsonName === (0, names_js_1.protoCamelCase)(proto.name)); + const b = { + name: proto.name, + number: proto.number, + type: proto.type, + }; + if ((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.label)) { + b.label = proto.label; + } + if ((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.typeName)) { + b.typeName = proto.typeName; + } + if ((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.extendee)) { + b.extendee = proto.extendee; + } + if ((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldDescriptorProtoSchema.field.defaultValue)) { + b.defaultValue = proto.defaultValue; + } + if (proto.options) { + b.options = createFieldOptionsBoot(proto.options); + } + return b; +} +function createFieldOptionsBoot(proto) { + const b = {}; + assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.ctype)); + if ((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.packed)) { + b.packed = proto.packed; + } + assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.jstype)); + assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.lazy)); + assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.unverifiedLazy)); + if ((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.deprecated)) { + b.deprecated = proto.deprecated; + } + assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.weak)); + assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.debugRedact)); + if ((0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.retention)) { + b.retention = proto.retention; + } + if (proto.targets.length) { + b.targets = proto.targets; + } + if (proto.editionDefaults.length) { + b.editionDefaults = proto.editionDefaults.map((d) => ({ + value: d.value, + edition: d.edition, + })); + } + assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.features)); + assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.FieldOptionsSchema.field.uninterpretedOption)); + return b; +} +function createEnumDescriptorBoot(proto) { + assert(!proto.options); + assert(!(0, fields_js_1.isFieldSet)(proto, descriptor_pb_js_1.EnumDescriptorProtoSchema.field.visibility)); + return { + name: proto.name, + value: proto.value.map((v) => { + assert(!v.options); + return { + name: v.name, + number: v.number, + }; + }), + }; +} +/** + * Assert that condition is truthy or throw error. + */ +function assert(condition) { + if (!condition) { + throw new Error(); + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/enum.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/enum.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e77b8fe2c555c39ee298558465124cc6d852c74f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/enum.d.ts @@ -0,0 +1,18 @@ +import type { DescEnum, DescFile } from "../descriptors.js"; +import type { GenEnum } from "./types.js"; +import type { JsonValue } from "../json-value.js"; +/** + * Hydrate an enum descriptor. + * + * @private + */ +export declare function enumDesc(file: DescFile, path: number, ...paths: number[]): GenEnum; +/** + * Construct a TypeScript enum object at runtime from a descriptor. + */ +export declare function tsEnum(desc: DescEnum): enumObject; +type enumObject = { + [key: number]: string; + [k: string]: number | string; +}; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/enum.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/enum.js new file mode 100644 index 0000000000000000000000000000000000000000..515d1d1044183904b365d2900e3ddb401491d4f1 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/enum.js @@ -0,0 +1,40 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.enumDesc = enumDesc; +exports.tsEnum = tsEnum; +/** + * Hydrate an enum descriptor. + * + * @private + */ +function enumDesc(file, path, ...paths) { + if (paths.length == 0) { + return file.enums[path]; + } + const e = paths.pop(); // we checked length above + return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]).nestedEnums[e]; +} +/** + * Construct a TypeScript enum object at runtime from a descriptor. + */ +function tsEnum(desc) { + const enumObject = {}; + for (const value of desc.values) { + enumObject[value.localName] = value.number; + enumObject[value.number] = value.localName; + } + return enumObject; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/extension.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/extension.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7d6374bcec186a977ddacd246b40d85b3eff055b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/extension.d.ts @@ -0,0 +1,9 @@ +import type { Message } from "../types.js"; +import type { DescFile } from "../descriptors.js"; +import type { GenExtension } from "./types.js"; +/** + * Hydrate an extension descriptor. + * + * @private + */ +export declare function extDesc(file: DescFile, path: number, ...paths: number[]): GenExtension; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/extension.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/extension.js new file mode 100644 index 0000000000000000000000000000000000000000..9d4947a41dbe98f92122edb89a72e40b226ab1d8 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/extension.js @@ -0,0 +1,28 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.extDesc = extDesc; +/** + * Hydrate an extension descriptor. + * + * @private + */ +function extDesc(file, path, ...paths) { + if (paths.length == 0) { + return file.extensions[path]; + } + const e = paths.pop(); // we checked length above + return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]).nestedExtensions[e]; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/file.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/file.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4d9853f347c363a6643e4a7cacba1afbf7ff9065 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/file.d.ts @@ -0,0 +1,7 @@ +import type { DescFile } from "../descriptors.js"; +/** + * Hydrate a file descriptor. + * + * @private + */ +export declare function fileDesc(b64: string, imports?: DescFile[]): DescFile; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/file.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/file.js new file mode 100644 index 0000000000000000000000000000000000000000..d559c87e6758b4fd49df845f94408c7c4326d5cb --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/file.js @@ -0,0 +1,35 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.fileDesc = fileDesc; +const base64_encoding_js_1 = require("../wire/base64-encoding.js"); +const descriptor_pb_js_1 = require("../wkt/gen/google/protobuf/descriptor_pb.js"); +const registry_js_1 = require("../registry.js"); +const restore_json_names_js_1 = require("./restore-json-names.js"); +const from_binary_js_1 = require("../from-binary.js"); +/** + * Hydrate a file descriptor. + * + * @private + */ +function fileDesc(b64, imports) { + var _a; + const root = (0, from_binary_js_1.fromBinary)(descriptor_pb_js_1.FileDescriptorProtoSchema, (0, base64_encoding_js_1.base64Decode)(b64)); + root.messageType.forEach(restore_json_names_js_1.restoreJsonNames); + root.dependency = (_a = imports === null || imports === void 0 ? void 0 : imports.map((f) => f.proto.name)) !== null && _a !== void 0 ? _a : []; + const reg = (0, registry_js_1.createFileRegistry)(root, (protoFileName) => imports === null || imports === void 0 ? void 0 : imports.find((f) => f.proto.name === protoFileName)); + // biome-ignore lint/style/noNonNullAssertion: non-null assertion because we just created the registry from the file we look up + return reg.getFile(root.name); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/index.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b74cd36f7e476b9fbbd83cd0a9e78f8769513a4b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/index.d.ts @@ -0,0 +1,10 @@ +export * from "./boot.js"; +export * from "./embed.js"; +export * from "./enum.js"; +export * from "./extension.js"; +export * from "./file.js"; +export * from "./message.js"; +export * from "./service.js"; +export * from "./symbols.js"; +export * from "./scalar.js"; +export * from "./types.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/index.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/index.js new file mode 100644 index 0000000000000000000000000000000000000000..05a2399c92be7a44199568357b52d45d37dd672f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/index.js @@ -0,0 +1,39 @@ +"use strict"; +// Copyright 2021-2025 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. +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./boot.js"), exports); +__exportStar(require("./embed.js"), exports); +__exportStar(require("./enum.js"), exports); +__exportStar(require("./extension.js"), exports); +__exportStar(require("./file.js"), exports); +__exportStar(require("./message.js"), exports); +__exportStar(require("./service.js"), exports); +__exportStar(require("./symbols.js"), exports); +__exportStar(require("./scalar.js"), exports); +__exportStar(require("./types.js"), exports); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/message.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/message.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f0f39779d7b5ec4ac7b4ffc534c6ccd43103fec4 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/message.d.ts @@ -0,0 +1,15 @@ +import type { Message } from "../types.js"; +import type { DescFile } from "../descriptors.js"; +import type { GenMessage } from "./types.js"; +/** + * Hydrate a message descriptor. + * + * @private + */ +export declare function messageDesc(file: DescFile, path: number, ...paths: number[]): GenMessage; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/message.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/message.js new file mode 100644 index 0000000000000000000000000000000000000000..e7219edde6e9cc68057c4a4e20dc1ae16e5f71bc --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/message.js @@ -0,0 +1,24 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.messageDesc = messageDesc; +/** + * Hydrate a message descriptor. + * + * @private + */ +function messageDesc(file, path, ...paths) { + return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/restore-json-names.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/restore-json-names.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d83d94ddc311c79dd96b46bbca4a6764f7dd1a5f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/restore-json-names.d.ts @@ -0,0 +1,5 @@ +import type { DescriptorProto } from "../wkt/gen/google/protobuf/descriptor_pb.js"; +/** + * @private + */ +export declare function restoreJsonNames(message: DescriptorProto): void; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/restore-json-names.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/restore-json-names.js new file mode 100644 index 0000000000000000000000000000000000000000..f57747b80a5c5866cdbc9e2f69b0d0e56a8927a5 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/restore-json-names.js @@ -0,0 +1,29 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.restoreJsonNames = restoreJsonNames; +const names_js_1 = require("../reflect/names.js"); +const unsafe_js_1 = require("../reflect/unsafe.js"); +/** + * @private + */ +function restoreJsonNames(message) { + for (const f of message.field) { + if (!(0, unsafe_js_1.unsafeIsSetExplicit)(f, "jsonName")) { + f.jsonName = (0, names_js_1.protoCamelCase)(f.name); + } + } + message.nestedType.forEach(restoreJsonNames); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/scalar.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/scalar.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5c48fceb954d6519008f19054fc1932e8b09ab57 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/scalar.d.ts @@ -0,0 +1,9 @@ +import { ScalarType } from "../descriptors.js"; +/** + * Return the TypeScript type (as a string) for the given scalar type. + */ +export declare function scalarTypeScriptType(scalar: ScalarType, longAsString: boolean): "string" | "boolean" | "bigint" | "bigint | string" | "Uint8Array" | "number"; +/** + * Return the JSON type (as a string) for the given scalar type. + */ +export declare function scalarJsonType(scalar: ScalarType): "string" | "boolean" | "number" | `number | "NaN" | "Infinity" | "-Infinity"`; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/scalar.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/scalar.js new file mode 100644 index 0000000000000000000000000000000000000000..e60bd781ce5499b8cbf31cc6be89e442655f96d0 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/scalar.js @@ -0,0 +1,67 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.scalarTypeScriptType = scalarTypeScriptType; +exports.scalarJsonType = scalarJsonType; +const descriptors_js_1 = require("../descriptors.js"); +/** + * Return the TypeScript type (as a string) for the given scalar type. + */ +function scalarTypeScriptType(scalar, longAsString) { + switch (scalar) { + case descriptors_js_1.ScalarType.STRING: + return "string"; + case descriptors_js_1.ScalarType.BOOL: + return "boolean"; + case descriptors_js_1.ScalarType.UINT64: + case descriptors_js_1.ScalarType.SFIXED64: + case descriptors_js_1.ScalarType.FIXED64: + case descriptors_js_1.ScalarType.SINT64: + case descriptors_js_1.ScalarType.INT64: + return longAsString ? "string" : "bigint"; + case descriptors_js_1.ScalarType.BYTES: + return "Uint8Array"; + default: + return "number"; + } +} +/** + * Return the JSON type (as a string) for the given scalar type. + */ +function scalarJsonType(scalar) { + switch (scalar) { + case descriptors_js_1.ScalarType.DOUBLE: + case descriptors_js_1.ScalarType.FLOAT: + return `number | "NaN" | "Infinity" | "-Infinity"`; + case descriptors_js_1.ScalarType.UINT64: + case descriptors_js_1.ScalarType.SFIXED64: + case descriptors_js_1.ScalarType.FIXED64: + case descriptors_js_1.ScalarType.SINT64: + case descriptors_js_1.ScalarType.INT64: + return "string"; + case descriptors_js_1.ScalarType.INT32: + case descriptors_js_1.ScalarType.FIXED32: + case descriptors_js_1.ScalarType.UINT32: + case descriptors_js_1.ScalarType.SFIXED32: + case descriptors_js_1.ScalarType.SINT32: + return "number"; + case descriptors_js_1.ScalarType.STRING: + return "string"; + case descriptors_js_1.ScalarType.BOOL: + return "boolean"; + case descriptors_js_1.ScalarType.BYTES: + return "string"; + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/service.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/service.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5818f75d547bf0b73e1da8d26ffb7e3f48bfa3f3 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/service.d.ts @@ -0,0 +1,8 @@ +import type { GenService, GenServiceMethods } from "./types.js"; +import type { DescFile } from "../descriptors.js"; +/** + * Hydrate a service descriptor. + * + * @private + */ +export declare function serviceDesc(file: DescFile, path: number, ...paths: number[]): GenService; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/service.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/service.js new file mode 100644 index 0000000000000000000000000000000000000000..8fb7f8b746b20aab0b88cd1611946c196dcc4ab1 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/service.js @@ -0,0 +1,27 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.serviceDesc = serviceDesc; +/** + * Hydrate a service descriptor. + * + * @private + */ +function serviceDesc(file, path, ...paths) { + if (paths.length > 0) { + throw new Error(); + } + return file.services[path]; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/symbols.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/symbols.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f9d850264d92fb00054f6579ea5a8d65dcdcfe05 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/symbols.d.ts @@ -0,0 +1,135 @@ +/** + * @private + */ +export declare const packageName = "@bufbuild/protobuf"; +/** + * @private + */ +export declare const wktPublicImportPaths: Readonly>; +/** + * @private + */ +export declare const symbols: { + readonly isMessage: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../is-message.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly Message: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../types.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly create: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../create.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly fromJson: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../from-json.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly fromJsonString: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../from-json.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly fromBinary: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../from-binary.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly toBinary: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../to-binary.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly toJson: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../to-json.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly toJsonString: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../to-json.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly protoInt64: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../proto-int64.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly JsonValue: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../json-value.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly JsonObject: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../json-value.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly codegen: { + readonly boot: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv2/boot.js"; + readonly from: string; + }; + readonly fileDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv2/file.js"; + readonly from: string; + }; + readonly enumDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv2/enum.js"; + readonly from: string; + }; + readonly extDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv2/extension.js"; + readonly from: string; + }; + readonly messageDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv2/message.js"; + readonly from: string; + }; + readonly serviceDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv2/service.js"; + readonly from: string; + }; + readonly tsEnum: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv2/enum.js"; + readonly from: string; + }; + readonly GenFile: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv2/types.js"; + readonly from: string; + }; + readonly GenEnum: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv2/types.js"; + readonly from: string; + }; + readonly GenExtension: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv2/types.js"; + readonly from: string; + }; + readonly GenMessage: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv2/types.js"; + readonly from: string; + }; + readonly GenService: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv2/types.js"; + readonly from: string; + }; + }; +}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/symbols.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/symbols.js new file mode 100644 index 0000000000000000000000000000000000000000..9d3a410443b0589fb562bb65505db62125a4899b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/symbols.js @@ -0,0 +1,72 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.symbols = exports.wktPublicImportPaths = exports.packageName = void 0; +/** + * @private + */ +exports.packageName = "@bufbuild/protobuf"; +/** + * @private + */ +exports.wktPublicImportPaths = { + "google/protobuf/compiler/plugin.proto": exports.packageName + "/wkt", + "google/protobuf/any.proto": exports.packageName + "/wkt", + "google/protobuf/api.proto": exports.packageName + "/wkt", + "google/protobuf/cpp_features.proto": exports.packageName + "/wkt", + "google/protobuf/descriptor.proto": exports.packageName + "/wkt", + "google/protobuf/duration.proto": exports.packageName + "/wkt", + "google/protobuf/empty.proto": exports.packageName + "/wkt", + "google/protobuf/field_mask.proto": exports.packageName + "/wkt", + "google/protobuf/go_features.proto": exports.packageName + "/wkt", + "google/protobuf/java_features.proto": exports.packageName + "/wkt", + "google/protobuf/source_context.proto": exports.packageName + "/wkt", + "google/protobuf/struct.proto": exports.packageName + "/wkt", + "google/protobuf/timestamp.proto": exports.packageName + "/wkt", + "google/protobuf/type.proto": exports.packageName + "/wkt", + "google/protobuf/wrappers.proto": exports.packageName + "/wkt", +}; +/** + * @private + */ +// biome-ignore format: want this to read well +exports.symbols = { + isMessage: { typeOnly: false, bootstrapWktFrom: "../../is-message.js", from: exports.packageName }, + Message: { typeOnly: true, bootstrapWktFrom: "../../types.js", from: exports.packageName }, + create: { typeOnly: false, bootstrapWktFrom: "../../create.js", from: exports.packageName }, + fromJson: { typeOnly: false, bootstrapWktFrom: "../../from-json.js", from: exports.packageName }, + fromJsonString: { typeOnly: false, bootstrapWktFrom: "../../from-json.js", from: exports.packageName }, + fromBinary: { typeOnly: false, bootstrapWktFrom: "../../from-binary.js", from: exports.packageName }, + toBinary: { typeOnly: false, bootstrapWktFrom: "../../to-binary.js", from: exports.packageName }, + toJson: { typeOnly: false, bootstrapWktFrom: "../../to-json.js", from: exports.packageName }, + toJsonString: { typeOnly: false, bootstrapWktFrom: "../../to-json.js", from: exports.packageName }, + protoInt64: { typeOnly: false, bootstrapWktFrom: "../../proto-int64.js", from: exports.packageName }, + JsonValue: { typeOnly: true, bootstrapWktFrom: "../../json-value.js", from: exports.packageName }, + JsonObject: { typeOnly: true, bootstrapWktFrom: "../../json-value.js", from: exports.packageName }, + codegen: { + boot: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/boot.js", from: exports.packageName + "/codegenv2" }, + fileDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/file.js", from: exports.packageName + "/codegenv2" }, + enumDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/enum.js", from: exports.packageName + "/codegenv2" }, + extDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/extension.js", from: exports.packageName + "/codegenv2" }, + messageDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/message.js", from: exports.packageName + "/codegenv2" }, + serviceDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/service.js", from: exports.packageName + "/codegenv2" }, + tsEnum: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/enum.js", from: exports.packageName + "/codegenv2" }, + GenFile: { typeOnly: true, bootstrapWktFrom: "../../codegenv2/types.js", from: exports.packageName + "/codegenv2" }, + GenEnum: { typeOnly: true, bootstrapWktFrom: "../../codegenv2/types.js", from: exports.packageName + "/codegenv2" }, + GenExtension: { typeOnly: true, bootstrapWktFrom: "../../codegenv2/types.js", from: exports.packageName + "/codegenv2" }, + GenMessage: { typeOnly: true, bootstrapWktFrom: "../../codegenv2/types.js", from: exports.packageName + "/codegenv2" }, + GenService: { typeOnly: true, bootstrapWktFrom: "../../codegenv2/types.js", from: exports.packageName + "/codegenv2" }, + }, +}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/types.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/types.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..286d368671bf87d8982f246461734072a2dedc33 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/types.d.ts @@ -0,0 +1,81 @@ +import type { Message } from "../types.js"; +import type { DescEnum, DescEnumValue, DescExtension, DescField, DescFile, DescMessage, DescMethod, DescService } from "../descriptors.js"; +import type { JsonValue } from "../json-value.js"; +/** + * Describes a protobuf source file. + * + * @private + */ +export type GenFile = DescFile; +/** + * Describes a message declaration in a protobuf source file. + * + * This type is identical to DescMessage, but carries additional type + * information. + * + * @private + */ +export type GenMessage = Omit & { + field: Record, DescField>; + typeName: RuntimeShape["$typeName"]; +} & brandv2; +/** + * Describes an enumeration in a protobuf source file. + * + * This type is identical to DescEnum, but carries additional type + * information. + * + * @private + */ +export type GenEnum = Omit & { + value: Record; +} & brandv2; +/** + * Describes an extension in a protobuf source file. + * + * This type is identical to DescExtension, but carries additional type + * information. + * + * @private + */ +export type GenExtension = DescExtension & brandv2; +/** + * Describes a service declaration in a protobuf source file. + * + * This type is identical to DescService, but carries additional type + * information. + * + * @private + */ +export type GenService = Omit & { + method: { + [K in keyof RuntimeShape]: RuntimeShape[K] & DescMethod; + }; +}; +/** + * @private + */ +export type GenServiceMethods = Record>; +declare class brandv2 { + protected v: "codegenv2"; + protected a: A | boolean; + protected b: B | boolean; +} +/** + * Union of the property names of all fields, including oneof members. + * For an anonymous message (no generated message shape), it's simply a string. + */ +type MessageFieldNames = Message extends T ? string : Exclude ? K : P]-?: true; +}, number | symbol>; +type Oneof = { + case: K | undefined; + value?: unknown; +}; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/types.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/types.js new file mode 100644 index 0000000000000000000000000000000000000000..cc8767f1ad4284c4f5726b940102c00b76ce8d90 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/codegenv2/types.js @@ -0,0 +1,22 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +class brandv2 { + constructor() { + this.v = "codegenv2"; + this.a = false; + this.b = false; + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/create.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/create.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0f86a361522a94c12d01108b0de456179ad9bf0a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/create.d.ts @@ -0,0 +1,9 @@ +import { type DescMessage } from "./descriptors.js"; +import type { MessageInitShape, MessageShape } from "./types.js"; +/** + * Create a new message instance. + * + * The second argument is an optional initializer object, where all fields are + * optional. + */ +export declare function create(schema: Desc, init?: MessageInitShape): MessageShape; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/create.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/create.js new file mode 100644 index 0000000000000000000000000000000000000000..e2416b89eb4d4b35d296d307e632f8a195907c04 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/create.js @@ -0,0 +1,259 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.create = create; +const is_message_js_1 = require("./is-message.js"); +const descriptors_js_1 = require("./descriptors.js"); +const scalar_js_1 = require("./reflect/scalar.js"); +const guard_js_1 = require("./reflect/guard.js"); +const unsafe_js_1 = require("./reflect/unsafe.js"); +const wrappers_js_1 = require("./wkt/wrappers.js"); +// bootstrap-inject google.protobuf.Edition.EDITION_PROTO3: const $name: Edition.$localName = $number; +const EDITION_PROTO3 = 999; +// bootstrap-inject google.protobuf.Edition.EDITION_PROTO2: const $name: Edition.$localName = $number; +const EDITION_PROTO2 = 998; +// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number; +const IMPLICIT = 2; +/** + * Create a new message instance. + * + * The second argument is an optional initializer object, where all fields are + * optional. + */ +function create(schema, init) { + if ((0, is_message_js_1.isMessage)(init, schema)) { + return init; + } + const message = createZeroMessage(schema); + if (init !== undefined) { + initMessage(schema, message, init); + } + return message; +} +/** + * Sets field values from a MessageInitShape on a zero message. + */ +function initMessage(messageDesc, message, init) { + for (const member of messageDesc.members) { + let value = init[member.localName]; + if (value == null) { + // intentionally ignore undefined and null + continue; + } + let field; + if (member.kind == "oneof") { + const oneofField = (0, unsafe_js_1.unsafeOneofCase)(init, member); + if (!oneofField) { + continue; + } + field = oneofField; + value = (0, unsafe_js_1.unsafeGet)(init, oneofField); + } + else { + field = member; + } + switch (field.fieldKind) { + case "message": + value = toMessage(field, value); + break; + case "scalar": + value = initScalar(field, value); + break; + case "list": + value = initList(field, value); + break; + case "map": + value = initMap(field, value); + break; + } + (0, unsafe_js_1.unsafeSet)(message, field, value); + } + return message; +} +function initScalar(field, value) { + if (field.scalar == descriptors_js_1.ScalarType.BYTES) { + return toU8Arr(value); + } + return value; +} +function initMap(field, value) { + if ((0, guard_js_1.isObject)(value)) { + if (field.scalar == descriptors_js_1.ScalarType.BYTES) { + return convertObjectValues(value, toU8Arr); + } + if (field.mapKind == "message") { + return convertObjectValues(value, (val) => toMessage(field, val)); + } + } + return value; +} +function initList(field, value) { + if (Array.isArray(value)) { + if (field.scalar == descriptors_js_1.ScalarType.BYTES) { + return value.map(toU8Arr); + } + if (field.listKind == "message") { + return value.map((item) => toMessage(field, item)); + } + } + return value; +} +function toMessage(field, value) { + if (field.fieldKind == "message" && + !field.oneof && + (0, wrappers_js_1.isWrapperDesc)(field.message)) { + // Types from google/protobuf/wrappers.proto are unwrapped when used in + // a singular field that is not part of a oneof group. + return initScalar(field.message.fields[0], value); + } + if ((0, guard_js_1.isObject)(value)) { + if (field.message.typeName == "google.protobuf.Struct" && + field.parent.typeName !== "google.protobuf.Value") { + // google.protobuf.Struct is represented with JsonObject when used in a + // field, except when used in google.protobuf.Value. + return value; + } + if (!(0, is_message_js_1.isMessage)(value, field.message)) { + return create(field.message, value); + } + } + return value; +} +// converts any ArrayLike to Uint8Array if necessary. +function toU8Arr(value) { + return Array.isArray(value) ? new Uint8Array(value) : value; +} +function convertObjectValues(obj, fn) { + const ret = {}; + for (const entry of Object.entries(obj)) { + ret[entry[0]] = fn(entry[1]); + } + return ret; +} +const tokenZeroMessageField = Symbol(); +const messagePrototypes = new WeakMap(); +/** + * Create a zero message. + */ +function createZeroMessage(desc) { + let msg; + if (!needsPrototypeChain(desc)) { + msg = { + $typeName: desc.typeName, + }; + for (const member of desc.members) { + if (member.kind == "oneof" || member.presence == IMPLICIT) { + msg[member.localName] = createZeroField(member); + } + } + } + else { + // Support default values and track presence via the prototype chain + const cached = messagePrototypes.get(desc); + let prototype; + let members; + if (cached) { + ({ prototype, members } = cached); + } + else { + prototype = {}; + members = new Set(); + for (const member of desc.members) { + if (member.kind == "oneof") { + // we can only put immutable values on the prototype, + // oneof ADTs are mutable + continue; + } + if (member.fieldKind != "scalar" && member.fieldKind != "enum") { + // only scalar and enum values are immutable, map, list, and message + // are not + continue; + } + if (member.presence == IMPLICIT) { + // implicit presence tracks field presence by zero values - e.g. 0, false, "", are unset, 1, true, "x" are set. + // message, map, list fields are mutable, and also have IMPLICIT presence. + continue; + } + members.add(member); + prototype[member.localName] = createZeroField(member); + } + messagePrototypes.set(desc, { prototype, members }); + } + msg = Object.create(prototype); + msg.$typeName = desc.typeName; + for (const member of desc.members) { + if (members.has(member)) { + continue; + } + if (member.kind == "field") { + if (member.fieldKind == "message") { + continue; + } + if (member.fieldKind == "scalar" || member.fieldKind == "enum") { + if (member.presence != IMPLICIT) { + continue; + } + } + } + msg[member.localName] = createZeroField(member); + } + } + return msg; +} +/** + * Do we need the prototype chain to track field presence? + */ +function needsPrototypeChain(desc) { + switch (desc.file.edition) { + case EDITION_PROTO3: + // proto3 always uses implicit presence, we never need the prototype chain. + return false; + case EDITION_PROTO2: + // proto2 never uses implicit presence, we always need the prototype chain. + return true; + default: + // If a message uses scalar or enum fields with explicit presence, we need + // the prototype chain to track presence. This rule does not apply to fields + // in a oneof group - they use a different mechanism to track presence. + return desc.fields.some((f) => f.presence != IMPLICIT && f.fieldKind != "message" && !f.oneof); + } +} +/** + * Returns a zero value for oneof groups, and for every field kind except + * messages. Scalar and enum fields can have default values. + */ +function createZeroField(field) { + if (field.kind == "oneof") { + return { case: undefined }; + } + if (field.fieldKind == "list") { + return []; + } + if (field.fieldKind == "map") { + return {}; // Object.create(null) would be desirable here, but is unsupported by react https://react.dev/reference/react/use-server#serializable-parameters-and-return-values + } + if (field.fieldKind == "message") { + return tokenZeroMessageField; + } + const defaultValue = field.getDefaultValue(); + if (defaultValue !== undefined) { + return field.fieldKind == "scalar" && field.longAsString + ? defaultValue.toString() + : defaultValue; + } + return field.fieldKind == "scalar" + ? (0, scalar_js_1.scalarZeroValue)(field.scalar, field.longAsString) + : field.enum.values[0].number; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/descriptors.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/descriptors.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..98e0c412f98853d1e0cf44c0c45d62c2f2e1c2b2 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/descriptors.d.ts @@ -0,0 +1,627 @@ +import type { DescriptorProto, Edition, EnumDescriptorProto, EnumValueDescriptorProto, FeatureSet_FieldPresence, FieldDescriptorProto, FileDescriptorProto, MethodDescriptorProto, MethodOptions_IdempotencyLevel, OneofDescriptorProto, ServiceDescriptorProto } from "./wkt/gen/google/protobuf/descriptor_pb.js"; +import type { ScalarValue } from "./reflect/scalar.js"; +export type SupportedEdition = Extract; +type SupportedFieldPresence = Extract; +/** + * Scalar value types. This is a subset of field types declared by protobuf + * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE + * are omitted, but the numerical values are identical. + */ +export declare enum ScalarType { + DOUBLE = 1, + FLOAT = 2, + INT64 = 3, + UINT64 = 4, + INT32 = 5, + FIXED64 = 6, + FIXED32 = 7, + BOOL = 8, + STRING = 9, + BYTES = 12, + UINT32 = 13, + SFIXED32 = 15, + SFIXED64 = 16, + SINT32 = 17,// Uses ZigZag encoding. + SINT64 = 18 +} +/** + * A union of all descriptors, discriminated by a `kind` property. + */ +export type AnyDesc = DescFile | DescEnum | DescEnumValue | DescMessage | DescField | DescExtension | DescOneof | DescService | DescMethod; +/** + * Describes a protobuf source file. + */ +export interface DescFile { + readonly kind: "file"; + /** + * The edition of the protobuf file. Will be EDITION_PROTO2 for syntax="proto2", + * EDITION_PROTO3 for syntax="proto3"; + */ + readonly edition: SupportedEdition; + /** + * The name of the file, excluding the .proto suffix. + * For a protobuf file `foo/bar.proto`, this is `foo/bar`. + */ + readonly name: string; + /** + * Files imported by this file. + */ + readonly dependencies: DescFile[]; + /** + * Top-level enumerations declared in this file. + * Note that more enumerations might be declared within message declarations. + */ + readonly enums: DescEnum[]; + /** + * Top-level messages declared in this file. + * Note that more messages might be declared within message declarations. + */ + readonly messages: DescMessage[]; + /** + * Top-level extensions declared in this file. + * Note that more extensions might be declared within message declarations. + */ + readonly extensions: DescExtension[]; + /** + * Services declared in this file. + */ + readonly services: DescService[]; + /** + * Marked as deprecated in the protobuf source. + */ + readonly deprecated: boolean; + /** + * The compiler-generated descriptor. + */ + readonly proto: FileDescriptorProto; + toString(): string; +} +/** + * Describes an enumeration in a protobuf source file. + */ +export interface DescEnum { + readonly kind: "enum"; + /** + * The fully qualified name of the enumeration. (We omit the leading dot.) + */ + readonly typeName: string; + /** + * The name of the enumeration, as declared in the protobuf source. + */ + readonly name: string; + /** + * The file this enumeration was declared in. + */ + readonly file: DescFile; + /** + * The parent message, if this enumeration was declared inside a message declaration. + */ + readonly parent: DescMessage | undefined; + /** + * Enumerations can be open or closed. + * See https://protobuf.dev/programming-guides/enum/ + */ + readonly open: boolean; + /** + * Values declared for this enumeration. + */ + readonly values: DescEnumValue[]; + /** + * All values of this enum by their number. + */ + readonly value: Record; + /** + * A prefix shared by all enum values. + * For example, `my_enum_` for `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}` + */ + readonly sharedPrefix?: string; + /** + * Marked as deprecated in the protobuf source. + */ + readonly deprecated: boolean; + /** + * The compiler-generated descriptor. + */ + readonly proto: EnumDescriptorProto; + toString(): string; +} +/** + * Describes an individual value of an enumeration in a protobuf source file. + */ +export interface DescEnumValue { + readonly kind: "enum_value"; + /** + * The name of the enumeration value, as specified in the protobuf source. + */ + readonly name: string; + /** + * A safe and idiomatic name for the value in a TypeScript enum. + */ + readonly localName: string; + /** + * The enumeration this value belongs to. + */ + readonly parent: DescEnum; + /** + * The numeric enumeration value, as specified in the protobuf source. + */ + readonly number: number; + /** + * Marked as deprecated in the protobuf source. + */ + readonly deprecated: boolean; + /** + * The compiler-generated descriptor. + */ + readonly proto: EnumValueDescriptorProto; + toString(): string; +} +/** + * Describes a message declaration in a protobuf source file. + */ +export interface DescMessage { + readonly kind: "message"; + /** + * The fully qualified name of the message. (We omit the leading dot.) + */ + readonly typeName: string; + /** + * The name of the message, as specified in the protobuf source. + */ + readonly name: string; + /** + * The file this message was declared in. + */ + readonly file: DescFile; + /** + * The parent message, if this message was declared inside a message declaration. + */ + readonly parent: DescMessage | undefined; + /** + * Fields declared for this message, including fields declared in a oneof + * group. + */ + readonly fields: DescField[]; + /** + * All fields of this message by their "localName". + */ + readonly field: Record; + /** + * Oneof groups declared for this message. + * This does not include synthetic oneofs for proto3 optionals. + */ + readonly oneofs: DescOneof[]; + /** + * Fields and oneof groups for this message, ordered by their appearance in the + * protobuf source. + */ + readonly members: (DescField | DescOneof)[]; + /** + * Enumerations declared within the message, if any. + */ + readonly nestedEnums: DescEnum[]; + /** + * Messages declared within the message, if any. + * This does not include synthetic messages like map entries. + */ + readonly nestedMessages: DescMessage[]; + /** + * Extensions declared within the message, if any. + */ + readonly nestedExtensions: DescExtension[]; + /** + * Marked as deprecated in the protobuf source. + */ + readonly deprecated: boolean; + /** + * The compiler-generated descriptor. + */ + readonly proto: DescriptorProto; + toString(): string; +} +/** + * Describes a field declaration in a protobuf source file. + */ +export type DescField = (descFieldScalar & descFieldCommon) | (descFieldList & descFieldCommon) | (descFieldMessage & descFieldCommon) | (descFieldEnum & descFieldCommon) | (descFieldMap & descFieldCommon); +type descFieldCommon = descFieldAndExtensionShared & { + readonly kind: "field"; + /** + * The message this field is declared on. + */ + readonly parent: DescMessage; + /** + * A safe and idiomatic name for the field as a property in ECMAScript. + */ + readonly localName: string; +}; +/** + * Describes an extension in a protobuf source file. + */ +export type DescExtension = (Omit & descExtensionCommon) | (Omit & descExtensionCommon) | (Omit & descExtensionCommon) | (descFieldList & descExtensionCommon); +type descExtensionCommon = descFieldAndExtensionShared & { + readonly kind: "extension"; + /** + * The fully qualified name of the extension. + */ + readonly typeName: string; + /** + * The file this extension was declared in. + */ + readonly file: DescFile; + /** + * The parent message, if this extension was declared inside a message declaration. + */ + readonly parent: DescMessage | undefined; + /** + * The message that this extension extends. + */ + readonly extendee: DescMessage; + /** + * The `oneof` group this field belongs to, if any. + */ + readonly oneof: undefined; +}; +interface descFieldAndExtensionShared { + /** + * The field name, as specified in the protobuf source + */ + readonly name: string; + /** + * The field number, as specified in the protobuf source. + */ + readonly number: number; + /** + * The field name in JSON. + */ + readonly jsonName: string; + /** + * Marked as deprecated in the protobuf source. + */ + readonly deprecated: boolean; + /** + * Presence of the field. + * See https://protobuf.dev/programming-guides/field_presence/ + */ + readonly presence: SupportedFieldPresence; + /** + * The compiler-generated descriptor. + */ + readonly proto: FieldDescriptorProto; + /** + * Get the edition features for this protobuf element. + */ + toString(): string; +} +type descFieldSingularCommon = { + /** + * The `oneof` group this field belongs to, if any. + * + * This does not include synthetic oneofs for proto3 optionals. + */ + readonly oneof: DescOneof | undefined; +}; +type descFieldScalar = T extends T ? { + readonly fieldKind: "scalar"; + /** + * Scalar type, if it is a scalar field. + */ + readonly scalar: T; + /** + * By default, 64-bit integral types (int64, uint64, sint64, fixed64, + * sfixed64) are represented with BigInt. + * + * If the field option `jstype = JS_STRING` is set, this property + * is true, and 64-bit integral types are represented with String. + */ + readonly longAsString: boolean; + /** + * The message type, if it is a message field. + */ + readonly message: undefined; + /** + * The enum type, if it is an enum field. + */ + readonly enum: undefined; + /** + * Return the default value specified in the protobuf source. + */ + getDefaultValue(): ScalarValue | undefined; +} & descFieldSingularCommon : never; +type descFieldMessage = { + readonly fieldKind: "message"; + /** + * Scalar type, if it is a scalar field. + */ + readonly scalar: undefined; + /** + * The message type, if it is a message field. + */ + readonly message: DescMessage; + /** + * Encode the message delimited (a.k.a. proto2 group encoding), or + * length-prefixed? + */ + readonly delimitedEncoding: boolean; + /** + * The enum type, if it is an enum field. + */ + readonly enum: undefined; + /** + * Return the default value specified in the protobuf source. + */ + getDefaultValue(): undefined; +} & descFieldSingularCommon; +type descFieldEnum = { + readonly fieldKind: "enum"; + /** + * Scalar type, if it is a scalar field. + */ + readonly scalar: undefined; + /** + * The message type, if it is a message field. + */ + readonly message: undefined; + /** + * The enum type, if it is an enum field. + */ + readonly enum: DescEnum; + /** + * Return the default value specified in the protobuf source. + */ + getDefaultValue(): number | undefined; +} & descFieldSingularCommon; +type descFieldList = (descFieldListScalar & descFieldListCommon) | (descFieldListEnum & descFieldListCommon) | (descFieldListMessage & descFieldListCommon); +type descFieldListCommon = { + readonly fieldKind: "list"; + /** + * Pack this repeated field? Only valid for repeated enum fields, and + * for repeated scalar fields except BYTES and STRING. + */ + readonly packed: boolean; + /** + * The `oneof` group this field belongs to, if any. + */ + readonly oneof: undefined; +}; +type descFieldListScalar = T extends T ? { + readonly listKind: "scalar"; + /** + * The enum list element type. + */ + readonly enum: undefined; + /** + * The message list element type. + */ + readonly message: undefined; + /** + * Scalar list element type. + */ + readonly scalar: T; + /** + * By default, 64-bit integral types (int64, uint64, sint64, fixed64, + * sfixed64) are represented with BigInt. + * + * If the field option `jstype = JS_STRING` is set, this property + * is true, and 64-bit integral types are represented with String. + */ + readonly longAsString: boolean; +} : never; +type descFieldListEnum = { + readonly listKind: "enum"; + /** + * The enum list element type. + */ + readonly enum: DescEnum; + /** + * The message list element type. + */ + readonly message: undefined; + /** + * Scalar list element type. + */ + readonly scalar: undefined; +}; +type descFieldListMessage = { + readonly listKind: "message"; + /** + * The enum list element type. + */ + readonly enum: undefined; + /** + * The message list element type. + */ + readonly message: DescMessage; + /** + * Scalar list element type. + */ + readonly scalar: undefined; + /** + * Encode the message delimited (a.k.a. proto2 group encoding), or + * length-prefixed? + */ + readonly delimitedEncoding: boolean; +}; +type descFieldMap = (descFieldMapScalar & descFieldMapCommon) | (descFieldMapEnum & descFieldMapCommon) | (descFieldMapMessage & descFieldMapCommon); +type descFieldMapCommon = T extends Exclude ? { + readonly fieldKind: "map"; + /** + * The scalar map key type. + */ + readonly mapKey: T; + /** + * The `oneof` group this field belongs to, if any. + */ + readonly oneof: undefined; + /** + * Encode the map entry message delimited (a.k.a. proto2 group encoding), + * or length-prefixed? As of Edition 2023, this is always false for map fields, + * and also applies to map values, if they are messages. + */ + readonly delimitedEncoding: false; +} : never; +type descFieldMapScalar = T extends T ? { + readonly mapKind: "scalar"; + /** + * The enum map value type. + */ + readonly enum: undefined; + /** + * The message map value type. + */ + readonly message: undefined; + /** + * Scalar map value type. + */ + readonly scalar: T; +} : never; +type descFieldMapEnum = { + readonly mapKind: "enum"; + /** + * The enum map value type. + */ + readonly enum: DescEnum; + /** + * The message map value type. + */ + readonly message: undefined; + /** + * Scalar map value type. + */ + readonly scalar: undefined; +}; +type descFieldMapMessage = { + readonly mapKind: "message"; + /** + * The enum map value type. + */ + readonly enum: undefined; + /** + * The message map value type. + */ + readonly message: DescMessage; + /** + * Scalar map value type. + */ + readonly scalar: undefined; +}; +/** + * Describes a oneof group in a protobuf source file. + */ +export interface DescOneof { + readonly kind: "oneof"; + /** + * The name of the oneof group, as specified in the protobuf source. + */ + readonly name: string; + /** + * A safe and idiomatic name for the oneof group as a property in ECMAScript. + */ + readonly localName: string; + /** + * The message this oneof group was declared in. + */ + readonly parent: DescMessage; + /** + * The fields declared in this oneof group. + */ + readonly fields: DescField[]; + /** + * Marked as deprecated in the protobuf source. + * Note that oneof groups cannot be marked as deprecated, this property + * only exists for consistency and will always be false. + */ + readonly deprecated: boolean; + /** + * The compiler-generated descriptor. + */ + readonly proto: OneofDescriptorProto; + toString(): string; +} +/** + * Describes a service declaration in a protobuf source file. + */ +export interface DescService { + readonly kind: "service"; + /** + * The fully qualified name of the service. (We omit the leading dot.) + */ + readonly typeName: string; + /** + * The name of the service, as specified in the protobuf source. + */ + readonly name: string; + /** + * The file this service was declared in. + */ + readonly file: DescFile; + /** + * The RPCs this service declares. + */ + readonly methods: DescMethod[]; + /** + * All methods of this service by their "localName". + */ + readonly method: Record; + /** + * Marked as deprecated in the protobuf source. + */ + readonly deprecated: boolean; + /** + * The compiler-generated descriptor. + */ + readonly proto: ServiceDescriptorProto; + toString(): string; +} +/** + * Describes an RPC declaration in a protobuf source file. + */ +export interface DescMethod { + readonly kind: "rpc"; + /** + * The name of the RPC, as specified in the protobuf source. + */ + readonly name: string; + /** + * A safe and idiomatic name for the RPC as a method in ECMAScript. + */ + readonly localName: string; + /** + * The parent service. + */ + readonly parent: DescService; + /** + * One of the four available method types. + */ + readonly methodKind: "unary" | "server_streaming" | "client_streaming" | "bidi_streaming"; + /** + * The message type for requests. + */ + readonly input: DescMessage; + /** + * The message type for responses. + */ + readonly output: DescMessage; + /** + * The idempotency level declared in the protobuf source, if any. + */ + readonly idempotency: MethodOptions_IdempotencyLevel; + /** + * Marked as deprecated in the protobuf source. + */ + readonly deprecated: boolean; + /** + * The compiler-generated descriptor. + */ + readonly proto: MethodDescriptorProto; + toString(): string; +} +/** + * Comments on an element in a protobuf source file. + */ +export interface DescComments { + readonly leadingDetached: readonly string[]; + readonly leading?: string; + readonly trailing?: string; + readonly sourcePath: readonly number[]; +} +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/descriptors.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/descriptors.js new file mode 100644 index 0000000000000000000000000000000000000000..c3d72ee5db5393bfe5d30400cf9f48f771b26601 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/descriptors.js @@ -0,0 +1,53 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ScalarType = void 0; +/** + * Scalar value types. This is a subset of field types declared by protobuf + * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE + * are omitted, but the numerical values are identical. + */ +var ScalarType; +(function (ScalarType) { + // 0 is reserved for errors. + // Order is weird for historical reasons. + ScalarType[ScalarType["DOUBLE"] = 1] = "DOUBLE"; + ScalarType[ScalarType["FLOAT"] = 2] = "FLOAT"; + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + // negative values are likely. + ScalarType[ScalarType["INT64"] = 3] = "INT64"; + ScalarType[ScalarType["UINT64"] = 4] = "UINT64"; + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + // negative values are likely. + ScalarType[ScalarType["INT32"] = 5] = "INT32"; + ScalarType[ScalarType["FIXED64"] = 6] = "FIXED64"; + ScalarType[ScalarType["FIXED32"] = 7] = "FIXED32"; + ScalarType[ScalarType["BOOL"] = 8] = "BOOL"; + ScalarType[ScalarType["STRING"] = 9] = "STRING"; + // Tag-delimited aggregate. + // Group type is deprecated and not supported in proto3. However, Proto3 + // implementations should still be able to parse the group wire format and + // treat group fields as unknown fields. + // TYPE_GROUP = 10, + // TYPE_MESSAGE = 11, // Length-delimited aggregate. + // New in version 2. + ScalarType[ScalarType["BYTES"] = 12] = "BYTES"; + ScalarType[ScalarType["UINT32"] = 13] = "UINT32"; + // TYPE_ENUM = 14, + ScalarType[ScalarType["SFIXED32"] = 15] = "SFIXED32"; + ScalarType[ScalarType["SFIXED64"] = 16] = "SFIXED64"; + ScalarType[ScalarType["SINT32"] = 17] = "SINT32"; + ScalarType[ScalarType["SINT64"] = 18] = "SINT64"; +})(ScalarType || (exports.ScalarType = ScalarType = {})); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/equals.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/equals.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..914048f1113e355bf52f78cafad18caf89bc0533 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/equals.d.ts @@ -0,0 +1,41 @@ +import type { MessageShape } from "./types.js"; +import { type DescMessage } from "./descriptors.js"; +import type { Registry } from "./registry.js"; +interface EqualsOptions { + /** + * A registry to look up extensions, and messages packed in Any. + * + * @private Experimental API, does not follow semantic versioning. + */ + registry: Registry; + /** + * Unpack google.protobuf.Any before comparing. + * If a type is not in the registry, comparison falls back to comparing the + * fields of Any. + * + * @private Experimental API, does not follow semantic versioning. + */ + unpackAny?: boolean; + /** + * Consider extensions when comparing. + * + * @private Experimental API, does not follow semantic versioning. + */ + extensions?: boolean; + /** + * Consider unknown fields when comparing. + * The registry is used to distinguish between extensions, and unknown fields + * caused by schema changes. + * + * @private Experimental API, does not follow semantic versioning. + */ + unknown?: boolean; +} +/** + * Compare two messages of the same type. + * + * Note that this function disregards extensions and unknown fields, and that + * NaN is not equal NaN, following the IEEE standard. + */ +export declare function equals(schema: Desc, a: MessageShape, b: MessageShape, options?: EqualsOptions): boolean; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/equals.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/equals.js new file mode 100644 index 0000000000000000000000000000000000000000..6954dd55fa2f3fa8465df7b4fa30efb1c6faf05e --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/equals.js @@ -0,0 +1,204 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.equals = equals; +const scalar_js_1 = require("./reflect/scalar.js"); +const reflect_js_1 = require("./reflect/reflect.js"); +const descriptors_js_1 = require("./descriptors.js"); +const index_js_1 = require("./wkt/index.js"); +const extensions_js_1 = require("./extensions.js"); +/** + * Compare two messages of the same type. + * + * Note that this function disregards extensions and unknown fields, and that + * NaN is not equal NaN, following the IEEE standard. + */ +function equals(schema, a, b, options) { + if (a.$typeName != schema.typeName || b.$typeName != schema.typeName) { + return false; + } + if (a === b) { + return true; + } + return reflectEquals((0, reflect_js_1.reflect)(schema, a), (0, reflect_js_1.reflect)(schema, b), options); +} +function reflectEquals(a, b, opts) { + if (a.desc.typeName === "google.protobuf.Any" && (opts === null || opts === void 0 ? void 0 : opts.unpackAny) == true) { + return anyUnpackedEquals(a.message, b.message, opts); + } + for (const f of a.fields) { + if (!fieldEquals(f, a, b, opts)) { + return false; + } + } + if ((opts === null || opts === void 0 ? void 0 : opts.unknown) == true && !unknownEquals(a, b, opts.registry)) { + return false; + } + if ((opts === null || opts === void 0 ? void 0 : opts.extensions) == true && !extensionsEquals(a, b, opts)) { + return false; + } + return true; +} +// TODO(tstamm) add an option to consider NaN equal to NaN? +function fieldEquals(f, a, b, opts) { + if (!a.isSet(f) && !b.isSet(f)) { + return true; + } + if (!a.isSet(f) || !b.isSet(f)) { + return false; + } + switch (f.fieldKind) { + case "scalar": + return (0, scalar_js_1.scalarEquals)(f.scalar, a.get(f), b.get(f)); + case "enum": + return a.get(f) === b.get(f); + case "message": + return reflectEquals(a.get(f), b.get(f), opts); + case "map": { + // TODO(tstamm) can't we compare sizes first? + const mapA = a.get(f); + const mapB = b.get(f); + const keys = []; + for (const k of mapA.keys()) { + if (!mapB.has(k)) { + return false; + } + keys.push(k); + } + for (const k of mapB.keys()) { + if (!mapA.has(k)) { + return false; + } + } + for (const key of keys) { + const va = mapA.get(key); + const vb = mapB.get(key); + if (va === vb) { + continue; + } + switch (f.mapKind) { + case "enum": + return false; + case "message": + if (!reflectEquals(va, vb, opts)) { + return false; + } + break; + case "scalar": + if (!(0, scalar_js_1.scalarEquals)(f.scalar, va, vb)) { + return false; + } + break; + } + } + break; + } + case "list": { + const listA = a.get(f); + const listB = b.get(f); + if (listA.size != listB.size) { + return false; + } + for (let i = 0; i < listA.size; i++) { + const va = listA.get(i); + const vb = listB.get(i); + if (va === vb) { + continue; + } + switch (f.listKind) { + case "enum": + return false; + case "message": + if (!reflectEquals(va, vb, opts)) { + return false; + } + break; + case "scalar": + if (!(0, scalar_js_1.scalarEquals)(f.scalar, va, vb)) { + return false; + } + break; + } + } + break; + } + } + return true; +} +function anyUnpackedEquals(a, b, opts) { + if (a.typeUrl !== b.typeUrl) { + return false; + } + const unpackedA = (0, index_js_1.anyUnpack)(a, opts.registry); + const unpackedB = (0, index_js_1.anyUnpack)(b, opts.registry); + if (unpackedA && unpackedB) { + const schema = opts.registry.getMessage(unpackedA.$typeName); + if (schema) { + return equals(schema, unpackedA, unpackedB, opts); + } + } + return (0, scalar_js_1.scalarEquals)(descriptors_js_1.ScalarType.BYTES, a.value, b.value); +} +function unknownEquals(a, b, registry) { + function getTrulyUnknown(msg, registry) { + var _a; + const u = (_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : []; + return registry + ? u.filter((uf) => !registry.getExtensionFor(msg.desc, uf.no)) + : u; + } + const unknownA = getTrulyUnknown(a, registry); + const unknownB = getTrulyUnknown(b, registry); + if (unknownA.length != unknownB.length) { + return false; + } + for (let i = 0; i < unknownA.length; i++) { + const a = unknownA[i]; + const b = unknownB[i]; + if (a.no != b.no) { + return false; + } + if (a.wireType != b.wireType) { + return false; + } + if (!(0, scalar_js_1.scalarEquals)(descriptors_js_1.ScalarType.BYTES, a.data, b.data)) { + return false; + } + } + return true; +} +function extensionsEquals(a, b, opts) { + function getSetExtensions(msg, registry) { + var _a; + return ((_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : []) + .map((uf) => registry.getExtensionFor(msg.desc, uf.no)) + .filter((e) => e != undefined) + .filter((e, index, arr) => arr.indexOf(e) === index); + } + const extensionsA = getSetExtensions(a, opts.registry); + const extensionsB = getSetExtensions(b, opts.registry); + if (extensionsA.length != extensionsB.length || + extensionsA.some((e) => !extensionsB.includes(e))) { + return false; + } + for (const extension of extensionsA) { + const [containerA, field] = (0, extensions_js_1.createExtensionContainer)(extension, (0, extensions_js_1.getExtension)(a.message, extension)); + const [containerB] = (0, extensions_js_1.createExtensionContainer)(extension, (0, extensions_js_1.getExtension)(b.message, extension)); + if (!fieldEquals(field, containerA, containerB, opts)) { + return false; + } + } + return true; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/extensions.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/extensions.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..83364472906fc70b9d9d4669fe98776e9e2fce19 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/extensions.d.ts @@ -0,0 +1,59 @@ +import type { AnyDesc, DescEnum, DescEnumValue, DescExtension, DescField, DescFile, DescMessage, DescMethod, DescOneof, DescService } from "./descriptors.js"; +import type { ReflectMessage } from "./reflect/reflect-types.js"; +import type { Extendee, ExtensionValueShape } from "./types.js"; +import type { EnumOptions, EnumValueOptions, FieldOptions, FileOptions, MessageOptions, MethodOptions, OneofOptions, ServiceOptions } from "./wkt/gen/google/protobuf/descriptor_pb.js"; +/** + * Retrieve an extension value from a message. + * + * The function never returns undefined. Use hasExtension() to check whether an + * extension is set. If the extension is not set, this function returns the + * default value (if one was specified in the protobuf source), or the zero value + * (for example `0` for numeric types, `[]` for repeated extension fields, and + * an empty message instance for message fields). + * + * Extensions are stored as unknown fields on a message. To mutate an extension + * value, make sure to store the new value with setExtension() after mutating. + * + * If the extension does not extend the given message, an error is raised. + */ +export declare function getExtension(message: Extendee, extension: Desc): ExtensionValueShape; +/** + * Set an extension value on a message. If the message already has a value for + * this extension, the value is replaced. + * + * If the extension does not extend the given message, an error is raised. + */ +export declare function setExtension(message: Extendee, extension: Desc, value: ExtensionValueShape): void; +/** + * Remove an extension value from a message. + * + * If the extension does not extend the given message, an error is raised. + */ +export declare function clearExtension(message: Extendee, extension: Desc): void; +/** + * Check whether an extension is set on a message. + */ +export declare function hasExtension(message: Extendee, extension: Desc): boolean; +/** + * Check whether an option is set on a descriptor. + * + * Options are extensions to the `google.protobuf.*Options` messages defined in + * google/protobuf/descriptor.proto. This function gets the option message from + * the descriptor, and calls hasExtension(). + */ +export declare function hasOption>(element: Desc, option: Ext): boolean; +/** + * Retrieve an option value from a descriptor. + * + * Options are extensions to the `google.protobuf.*Options` messages defined in + * google/protobuf/descriptor.proto. This function gets the option message from + * the descriptor, and calls getExtension(). Same as getExtension(), this + * function never returns undefined. + */ +export declare function getOption>(element: Desc, option: Ext): ExtensionValueShape; +type DescForOptionExtension = Extendee extends FileOptions ? DescFile : Extendee extends EnumOptions ? DescEnum : Extendee extends EnumValueOptions ? DescEnumValue : Extendee extends MessageOptions ? DescMessage : Extendee extends MessageOptions ? DescEnum : Extendee extends FieldOptions ? DescField | DescExtension : Extendee extends OneofOptions ? DescOneof : Extendee extends ServiceOptions ? DescService : Extendee extends EnumOptions ? DescEnum : Extendee extends MethodOptions ? DescMethod : AnyDesc; +/** + * @private + */ +export declare function createExtensionContainer(extension: Desc, value?: ExtensionValueShape): [ReflectMessage, DescField, () => ExtensionValueShape]; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/extensions.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/extensions.js new file mode 100644 index 0000000000000000000000000000000000000000..93c807ea207f9e1d831c39d2676a8059ca2b827d --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/extensions.js @@ -0,0 +1,169 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getExtension = getExtension; +exports.setExtension = setExtension; +exports.clearExtension = clearExtension; +exports.hasExtension = hasExtension; +exports.hasOption = hasOption; +exports.getOption = getOption; +exports.createExtensionContainer = createExtensionContainer; +const create_js_1 = require("./create.js"); +const from_binary_js_1 = require("./from-binary.js"); +const reflect_js_1 = require("./reflect/reflect.js"); +const scalar_js_1 = require("./reflect/scalar.js"); +const to_binary_js_1 = require("./to-binary.js"); +const binary_encoding_js_1 = require("./wire/binary-encoding.js"); +const wrappers_js_1 = require("./wkt/wrappers.js"); +/** + * Retrieve an extension value from a message. + * + * The function never returns undefined. Use hasExtension() to check whether an + * extension is set. If the extension is not set, this function returns the + * default value (if one was specified in the protobuf source), or the zero value + * (for example `0` for numeric types, `[]` for repeated extension fields, and + * an empty message instance for message fields). + * + * Extensions are stored as unknown fields on a message. To mutate an extension + * value, make sure to store the new value with setExtension() after mutating. + * + * If the extension does not extend the given message, an error is raised. + */ +function getExtension(message, extension) { + assertExtendee(extension, message); + const ufs = filterUnknownFields(message.$unknown, extension); + const [container, field, get] = createExtensionContainer(extension); + for (const uf of ufs) { + (0, from_binary_js_1.readField)(container, new binary_encoding_js_1.BinaryReader(uf.data), field, uf.wireType, { + readUnknownFields: true, + }); + } + return get(); +} +/** + * Set an extension value on a message. If the message already has a value for + * this extension, the value is replaced. + * + * If the extension does not extend the given message, an error is raised. + */ +function setExtension(message, extension, value) { + var _a; + assertExtendee(extension, message); + const ufs = ((_a = message.$unknown) !== null && _a !== void 0 ? _a : []).filter((uf) => uf.no !== extension.number); + const [container, field] = createExtensionContainer(extension, value); + const writer = new binary_encoding_js_1.BinaryWriter(); + (0, to_binary_js_1.writeField)(writer, { writeUnknownFields: true }, container, field); + const reader = new binary_encoding_js_1.BinaryReader(writer.finish()); + while (reader.pos < reader.len) { + const [no, wireType] = reader.tag(); + const data = reader.skip(wireType, no); + ufs.push({ no, wireType, data }); + } + message.$unknown = ufs; +} +/** + * Remove an extension value from a message. + * + * If the extension does not extend the given message, an error is raised. + */ +function clearExtension(message, extension) { + assertExtendee(extension, message); + if (message.$unknown === undefined) { + return; + } + message.$unknown = message.$unknown.filter((uf) => uf.no !== extension.number); +} +/** + * Check whether an extension is set on a message. + */ +function hasExtension(message, extension) { + var _a; + return (extension.extendee.typeName === message.$typeName && + !!((_a = message.$unknown) === null || _a === void 0 ? void 0 : _a.find((uf) => uf.no === extension.number))); +} +/** + * Check whether an option is set on a descriptor. + * + * Options are extensions to the `google.protobuf.*Options` messages defined in + * google/protobuf/descriptor.proto. This function gets the option message from + * the descriptor, and calls hasExtension(). + */ +function hasOption(element, option) { + const message = element.proto.options; + if (!message) { + return false; + } + return hasExtension(message, option); +} +/** + * Retrieve an option value from a descriptor. + * + * Options are extensions to the `google.protobuf.*Options` messages defined in + * google/protobuf/descriptor.proto. This function gets the option message from + * the descriptor, and calls getExtension(). Same as getExtension(), this + * function never returns undefined. + */ +function getOption(element, option) { + const message = element.proto.options; + if (!message) { + const [, , get] = createExtensionContainer(option); + return get(); + } + return getExtension(message, option); +} +function filterUnknownFields(unknownFields, extension) { + if (unknownFields === undefined) + return []; + if (extension.fieldKind === "enum" || extension.fieldKind === "scalar") { + // singular scalar fields do not merge, we pick the last + for (let i = unknownFields.length - 1; i >= 0; --i) { + if (unknownFields[i].no == extension.number) { + return [unknownFields[i]]; + } + } + return []; + } + return unknownFields.filter((uf) => uf.no === extension.number); +} +/** + * @private + */ +function createExtensionContainer(extension, value) { + const localName = extension.typeName; + const field = Object.assign(Object.assign({}, extension), { kind: "field", parent: extension.extendee, localName }); + const desc = Object.assign(Object.assign({}, extension.extendee), { fields: [field], members: [field], oneofs: [] }); + const container = (0, create_js_1.create)(desc, value !== undefined ? { [localName]: value } : undefined); + return [ + (0, reflect_js_1.reflect)(desc, container), + field, + () => { + const value = container[localName]; + if (value === undefined) { + // biome-ignore lint/style/noNonNullAssertion: Only message fields are undefined, rest will have a zero value. + const desc = extension.message; + if ((0, wrappers_js_1.isWrapperDesc)(desc)) { + return (0, scalar_js_1.scalarZeroValue)(desc.fields[0].scalar, desc.fields[0].longAsString); + } + return (0, create_js_1.create)(desc); + } + return value; + }, + ]; +} +function assertExtendee(extension, message) { + if (extension.extendee.typeName != message.$typeName) { + throw new Error(`extension ${extension.typeName} can only be applied to message ${extension.extendee.typeName}`); + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/fields.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/fields.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a44a0c87280b251a4c7fd1b83d0e170c9a588d10 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/fields.d.ts @@ -0,0 +1,23 @@ +import type { MessageShape } from "./types.js"; +import type { DescField, DescMessage } from "./descriptors.js"; +/** + * Returns true if the field is set. + * + * - Scalar and enum fields with implicit presence (proto3): + * Set if not a zero value. + * + * - Scalar and enum fields with explicit presence (proto2, oneof): + * Set if a value was set when creating or parsing the message, or when a + * value was assigned to the field's property. + * + * - Message fields: + * Set if the property is not undefined. + * + * - List and map fields: + * Set if not empty. + */ +export declare function isFieldSet(message: MessageShape, field: DescField): boolean; +/** + * Resets the field, so that isFieldSet() will return false. + */ +export declare function clearField(message: MessageShape, field: DescField): void; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/fields.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/fields.js new file mode 100644 index 0000000000000000000000000000000000000000..6e569cc0b78d7d89c3efb39bf4edb1f89c75ba48 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/fields.js @@ -0,0 +1,45 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isFieldSet = isFieldSet; +exports.clearField = clearField; +const unsafe_js_1 = require("./reflect/unsafe.js"); +/** + * Returns true if the field is set. + * + * - Scalar and enum fields with implicit presence (proto3): + * Set if not a zero value. + * + * - Scalar and enum fields with explicit presence (proto2, oneof): + * Set if a value was set when creating or parsing the message, or when a + * value was assigned to the field's property. + * + * - Message fields: + * Set if the property is not undefined. + * + * - List and map fields: + * Set if not empty. + */ +function isFieldSet(message, field) { + return (field.parent.typeName == message.$typeName && (0, unsafe_js_1.unsafeIsSet)(message, field)); +} +/** + * Resets the field, so that isFieldSet() will return false. + */ +function clearField(message, field) { + if (field.parent.typeName == message.$typeName) { + (0, unsafe_js_1.unsafeClear)(message, field); + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/from-binary.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/from-binary.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b04a9d39ed2ca08cb6329fb5ffed916868f8f5db --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/from-binary.d.ts @@ -0,0 +1,34 @@ +import { type DescField, type DescMessage } from "./descriptors.js"; +import type { MessageShape } from "./types.js"; +import type { ReflectMessage } from "./reflect/index.js"; +import { BinaryReader, WireType } from "./wire/binary-encoding.js"; +/** + * Options for parsing binary data. + */ +export interface BinaryReadOptions { + /** + * Retain unknown fields during parsing? The default behavior is to retain + * unknown fields and include them in the serialized output. + * + * For more details see https://developers.google.com/protocol-buffers/docs/proto3#unknowns + */ + readUnknownFields: boolean; +} +/** + * Parse serialized binary data. + */ +export declare function fromBinary(schema: Desc, bytes: Uint8Array, options?: Partial): MessageShape; +/** + * Parse from binary data, merging fields. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ +export declare function mergeFromBinary(schema: Desc, target: MessageShape, bytes: Uint8Array, options?: Partial): MessageShape; +/** + * @private + */ +export declare function readField(message: ReflectMessage, reader: BinaryReader, field: DescField, wireType: WireType, options: BinaryReadOptions): void; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/from-binary.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/from-binary.js new file mode 100644 index 0000000000000000000000000000000000000000..484281a0661c761b359f94c2b5bddb0c4137d71f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/from-binary.js @@ -0,0 +1,241 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.fromBinary = fromBinary; +exports.mergeFromBinary = mergeFromBinary; +exports.readField = readField; +const descriptors_js_1 = require("./descriptors.js"); +const scalar_js_1 = require("./reflect/scalar.js"); +const reflect_js_1 = require("./reflect/reflect.js"); +const binary_encoding_js_1 = require("./wire/binary-encoding.js"); +const varint_js_1 = require("./wire/varint.js"); +// Default options for parsing binary data. +const readDefaults = { + readUnknownFields: true, +}; +function makeReadOptions(options) { + return options ? Object.assign(Object.assign({}, readDefaults), options) : readDefaults; +} +/** + * Parse serialized binary data. + */ +function fromBinary(schema, bytes, options) { + const msg = (0, reflect_js_1.reflect)(schema, undefined, false); + readMessage(msg, new binary_encoding_js_1.BinaryReader(bytes), makeReadOptions(options), false, bytes.byteLength); + return msg.message; +} +/** + * Parse from binary data, merging fields. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ +function mergeFromBinary(schema, target, bytes, options) { + readMessage((0, reflect_js_1.reflect)(schema, target, false), new binary_encoding_js_1.BinaryReader(bytes), makeReadOptions(options), false, bytes.byteLength); + return target; +} +/** + * If `delimited` is false, read the length given in `lengthOrDelimitedFieldNo`. + * + * If `delimited` is true, read until an EndGroup tag. `lengthOrDelimitedFieldNo` + * is the expected field number. + * + * @private + */ +function readMessage(message, reader, options, delimited, lengthOrDelimitedFieldNo) { + var _a; + const end = delimited ? reader.len : reader.pos + lengthOrDelimitedFieldNo; + let fieldNo; + let wireType; + const unknownFields = (_a = message.getUnknown()) !== null && _a !== void 0 ? _a : []; + while (reader.pos < end) { + [fieldNo, wireType] = reader.tag(); + if (delimited && wireType == binary_encoding_js_1.WireType.EndGroup) { + break; + } + const field = message.findNumber(fieldNo); + if (!field) { + const data = reader.skip(wireType, fieldNo); + if (options.readUnknownFields) { + unknownFields.push({ no: fieldNo, wireType, data }); + } + continue; + } + readField(message, reader, field, wireType, options); + } + if (delimited) { + if (wireType != binary_encoding_js_1.WireType.EndGroup || fieldNo !== lengthOrDelimitedFieldNo) { + throw new Error("invalid end group tag"); + } + } + if (unknownFields.length > 0) { + message.setUnknown(unknownFields); + } +} +/** + * @private + */ +function readField(message, reader, field, wireType, options) { + var _a; + switch (field.fieldKind) { + case "scalar": + message.set(field, readScalar(reader, field.scalar)); + break; + case "enum": + const val = readScalar(reader, descriptors_js_1.ScalarType.INT32); + if (field.enum.open) { + message.set(field, val); + } + else { + const ok = field.enum.values.some((v) => v.number === val); + if (ok) { + message.set(field, val); + } + else if (options.readUnknownFields) { + const bytes = []; + (0, varint_js_1.varint32write)(val, bytes); + const unknownFields = (_a = message.getUnknown()) !== null && _a !== void 0 ? _a : []; + unknownFields.push({ + no: field.number, + wireType, + data: new Uint8Array(bytes), + }); + message.setUnknown(unknownFields); + } + } + break; + case "message": + message.set(field, readMessageField(reader, options, field, message.get(field))); + break; + case "list": + readListField(reader, wireType, message.get(field), options); + break; + case "map": + readMapEntry(reader, message.get(field), options); + break; + } +} +// Read a map field, expecting key field = 1, value field = 2 +function readMapEntry(reader, map, options) { + const field = map.field(); + let key; + let val; + // Read the length of the map entry, which is a varint. + const len = reader.uint32(); + // WARNING: Calculate end AFTER advancing reader.pos (above), so that + // reader.pos is at the start of the map entry. + const end = reader.pos + len; + while (reader.pos < end) { + const [fieldNo] = reader.tag(); + switch (fieldNo) { + case 1: + key = readScalar(reader, field.mapKey); + break; + case 2: + switch (field.mapKind) { + case "scalar": + val = readScalar(reader, field.scalar); + break; + case "enum": + val = reader.int32(); + break; + case "message": + val = readMessageField(reader, options, field); + break; + } + break; + } + } + if (key === undefined) { + key = (0, scalar_js_1.scalarZeroValue)(field.mapKey, false); + } + if (val === undefined) { + switch (field.mapKind) { + case "scalar": + val = (0, scalar_js_1.scalarZeroValue)(field.scalar, false); + break; + case "enum": + val = field.enum.values[0].number; + break; + case "message": + val = (0, reflect_js_1.reflect)(field.message, undefined, false); + break; + } + } + map.set(key, val); +} +function readListField(reader, wireType, list, options) { + var _a; + const field = list.field(); + if (field.listKind === "message") { + list.add(readMessageField(reader, options, field)); + return; + } + const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : descriptors_js_1.ScalarType.INT32; + const packed = wireType == binary_encoding_js_1.WireType.LengthDelimited && + scalarType != descriptors_js_1.ScalarType.STRING && + scalarType != descriptors_js_1.ScalarType.BYTES; + if (!packed) { + list.add(readScalar(reader, scalarType)); + return; + } + const e = reader.uint32() + reader.pos; + while (reader.pos < e) { + list.add(readScalar(reader, scalarType)); + } +} +function readMessageField(reader, options, field, mergeMessage) { + const delimited = field.delimitedEncoding; + const message = mergeMessage !== null && mergeMessage !== void 0 ? mergeMessage : (0, reflect_js_1.reflect)(field.message, undefined, false); + readMessage(message, reader, options, delimited, delimited ? field.number : reader.uint32()); + return message; +} +function readScalar(reader, type) { + switch (type) { + case descriptors_js_1.ScalarType.STRING: + return reader.string(); + case descriptors_js_1.ScalarType.BOOL: + return reader.bool(); + case descriptors_js_1.ScalarType.DOUBLE: + return reader.double(); + case descriptors_js_1.ScalarType.FLOAT: + return reader.float(); + case descriptors_js_1.ScalarType.INT32: + return reader.int32(); + case descriptors_js_1.ScalarType.INT64: + return reader.int64(); + case descriptors_js_1.ScalarType.UINT64: + return reader.uint64(); + case descriptors_js_1.ScalarType.FIXED64: + return reader.fixed64(); + case descriptors_js_1.ScalarType.BYTES: + return reader.bytes(); + case descriptors_js_1.ScalarType.FIXED32: + return reader.fixed32(); + case descriptors_js_1.ScalarType.SFIXED32: + return reader.sfixed32(); + case descriptors_js_1.ScalarType.SFIXED64: + return reader.sfixed64(); + case descriptors_js_1.ScalarType.SINT64: + return reader.sint64(); + case descriptors_js_1.ScalarType.UINT32: + return reader.uint32(); + case descriptors_js_1.ScalarType.SINT32: + return reader.sint32(); + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/from-json.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/from-json.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..06f4d6c17928a8fa36d22247baea8528f58e5d8c --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/from-json.d.ts @@ -0,0 +1,56 @@ +import { type DescEnum, type DescMessage } from "./descriptors.js"; +import type { JsonValue } from "./json-value.js"; +import type { Registry } from "./registry.js"; +import type { EnumJsonType, EnumShape, MessageShape } from "./types.js"; +/** + * Options for parsing JSON data. + */ +export interface JsonReadOptions { + /** + * Ignore unknown fields: Proto3 JSON parser should reject unknown fields + * by default. This option ignores unknown fields in parsing, as well as + * unrecognized enum string representations. + */ + ignoreUnknownFields: boolean; + /** + * This option is required to read `google.protobuf.Any` and extensions + * from JSON format. + */ + registry?: Registry; +} +/** + * Parse a message from a JSON string. + */ +export declare function fromJsonString(schema: Desc, json: string, options?: Partial): MessageShape; +/** + * Parse a message from a JSON string, merging fields. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ +export declare function mergeFromJsonString(schema: Desc, target: MessageShape, json: string, options?: Partial): MessageShape; +/** + * Parse a message from a JSON value. + */ +export declare function fromJson(schema: Desc, json: JsonValue, options?: Partial): MessageShape; +/** + * Parse a message from a JSON value, merging fields. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ +export declare function mergeFromJson(schema: Desc, target: MessageShape, json: JsonValue, options?: Partial): MessageShape; +/** + * Parses an enum value from JSON. + */ +export declare function enumFromJson(descEnum: Desc, json: EnumJsonType): EnumShape; +/** + * Is the given value a JSON enum value? + */ +export declare function isEnumJson(descEnum: Desc, value: unknown): value is EnumJsonType; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/from-json.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/from-json.js new file mode 100644 index 0000000000000000000000000000000000000000..06e5a2483b1b69d7f2641f267c43050fc81b7cc0 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/from-json.js @@ -0,0 +1,622 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.fromJsonString = fromJsonString; +exports.mergeFromJsonString = mergeFromJsonString; +exports.fromJson = fromJson; +exports.mergeFromJson = mergeFromJson; +exports.enumFromJson = enumFromJson; +exports.isEnumJson = isEnumJson; +const descriptors_js_1 = require("./descriptors.js"); +const proto_int64_js_1 = require("./proto-int64.js"); +const create_js_1 = require("./create.js"); +const reflect_js_1 = require("./reflect/reflect.js"); +const error_js_1 = require("./reflect/error.js"); +const reflect_check_js_1 = require("./reflect/reflect-check.js"); +const scalar_js_1 = require("./reflect/scalar.js"); +const base64_encoding_js_1 = require("./wire/base64-encoding.js"); +const index_js_1 = require("./wkt/index.js"); +const extensions_js_1 = require("./extensions.js"); +// Default options for parsing JSON. +const jsonReadDefaults = { + ignoreUnknownFields: false, +}; +function makeReadOptions(options) { + return options ? Object.assign(Object.assign({}, jsonReadDefaults), options) : jsonReadDefaults; +} +/** + * Parse a message from a JSON string. + */ +function fromJsonString(schema, json, options) { + return fromJson(schema, parseJsonString(json, schema.typeName), options); +} +/** + * Parse a message from a JSON string, merging fields. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ +function mergeFromJsonString(schema, target, json, options) { + return mergeFromJson(schema, target, parseJsonString(json, schema.typeName), options); +} +/** + * Parse a message from a JSON value. + */ +function fromJson(schema, json, options) { + const msg = (0, reflect_js_1.reflect)(schema); + try { + readMessage(msg, json, makeReadOptions(options)); + } + catch (e) { + if ((0, error_js_1.isFieldError)(e)) { + // @ts-expect-error we use the ES2022 error CTOR option "cause" for better stack traces + throw new Error(`cannot decode ${e.field()} from JSON: ${e.message}`, { + cause: e, + }); + } + throw e; + } + return msg.message; +} +/** + * Parse a message from a JSON value, merging fields. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ +function mergeFromJson(schema, target, json, options) { + try { + readMessage((0, reflect_js_1.reflect)(schema, target), json, makeReadOptions(options)); + } + catch (e) { + if ((0, error_js_1.isFieldError)(e)) { + // @ts-expect-error we use the ES2022 error CTOR option "cause" for better stack traces + throw new Error(`cannot decode ${e.field()} from JSON: ${e.message}`, { + cause: e, + }); + } + throw e; + } + return target; +} +/** + * Parses an enum value from JSON. + */ +function enumFromJson(descEnum, json) { + const val = readEnum(descEnum, json, false, false); + if (val === tokenIgnoredUnknownEnum) { + throw new Error(`cannot decode ${descEnum} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`); + } + return val; +} +/** + * Is the given value a JSON enum value? + */ +function isEnumJson(descEnum, value) { + return undefined !== descEnum.values.find((v) => v.name === value); +} +function readMessage(msg, json, opts) { + var _a; + if (tryWktFromJson(msg, json, opts)) { + return; + } + if (json == null || Array.isArray(json) || typeof json != "object") { + throw new Error(`cannot decode ${msg.desc} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`); + } + const oneofSeen = new Map(); + const jsonNames = new Map(); + for (const field of msg.desc.fields) { + jsonNames.set(field.name, field).set(field.jsonName, field); + } + for (const [jsonKey, jsonValue] of Object.entries(json)) { + const field = jsonNames.get(jsonKey); + if (field) { + if (field.oneof) { + if (jsonValue === null && field.fieldKind == "scalar") { + // see conformance test Required.Proto3.JsonInput.OneofFieldNull{First,Second} + continue; + } + const seen = oneofSeen.get(field.oneof); + if (seen !== undefined) { + throw new error_js_1.FieldError(field.oneof, `oneof set multiple times by ${seen.name} and ${field.name}`); + } + oneofSeen.set(field.oneof, field); + } + readField(msg, field, jsonValue, opts); + } + else { + let extension = undefined; + if (jsonKey.startsWith("[") && + jsonKey.endsWith("]") && + // biome-ignore lint/suspicious/noAssignInExpressions: no + (extension = (_a = opts.registry) === null || _a === void 0 ? void 0 : _a.getExtension(jsonKey.substring(1, jsonKey.length - 1))) && + extension.extendee.typeName === msg.desc.typeName) { + const [container, field, get] = (0, extensions_js_1.createExtensionContainer)(extension); + readField(container, field, jsonValue, opts); + (0, extensions_js_1.setExtension)(msg.message, extension, get()); + } + if (!extension && !opts.ignoreUnknownFields) { + throw new Error(`cannot decode ${msg.desc} from JSON: key "${jsonKey}" is unknown`); + } + } + } +} +function readField(msg, field, json, opts) { + switch (field.fieldKind) { + case "scalar": + readScalarField(msg, field, json); + break; + case "enum": + readEnumField(msg, field, json, opts); + break; + case "message": + readMessageField(msg, field, json, opts); + break; + case "list": + readListField(msg.get(field), json, opts); + break; + case "map": + readMapField(msg.get(field), json, opts); + break; + } +} +function readMapField(map, json, opts) { + if (json === null) { + return; + } + const field = map.field(); + if (typeof json != "object" || Array.isArray(json)) { + throw new error_js_1.FieldError(field, "expected object, got " + (0, reflect_check_js_1.formatVal)(json)); + } + for (const [jsonMapKey, jsonMapValue] of Object.entries(json)) { + if (jsonMapValue === null) { + throw new error_js_1.FieldError(field, "map value must not be null"); + } + let value; + switch (field.mapKind) { + case "message": + const msgValue = (0, reflect_js_1.reflect)(field.message); + readMessage(msgValue, jsonMapValue, opts); + value = msgValue; + break; + case "enum": + value = readEnum(field.enum, jsonMapValue, opts.ignoreUnknownFields, true); + if (value === tokenIgnoredUnknownEnum) { + return; + } + break; + case "scalar": + value = scalarFromJson(field, jsonMapValue, true); + break; + } + const key = mapKeyFromJson(field.mapKey, jsonMapKey); + map.set(key, value); + } +} +function readListField(list, json, opts) { + if (json === null) { + return; + } + const field = list.field(); + if (!Array.isArray(json)) { + throw new error_js_1.FieldError(field, "expected Array, got " + (0, reflect_check_js_1.formatVal)(json)); + } + for (const jsonItem of json) { + if (jsonItem === null) { + throw new error_js_1.FieldError(field, "list item must not be null"); + } + switch (field.listKind) { + case "message": + const msgValue = (0, reflect_js_1.reflect)(field.message); + readMessage(msgValue, jsonItem, opts); + list.add(msgValue); + break; + case "enum": + const enumValue = readEnum(field.enum, jsonItem, opts.ignoreUnknownFields, true); + if (enumValue !== tokenIgnoredUnknownEnum) { + list.add(enumValue); + } + break; + case "scalar": + list.add(scalarFromJson(field, jsonItem, true)); + break; + } + } +} +function readMessageField(msg, field, json, opts) { + if (json === null && field.message.typeName != "google.protobuf.Value") { + msg.clear(field); + return; + } + const msgValue = msg.isSet(field) ? msg.get(field) : (0, reflect_js_1.reflect)(field.message); + readMessage(msgValue, json, opts); + msg.set(field, msgValue); +} +function readEnumField(msg, field, json, opts) { + const enumValue = readEnum(field.enum, json, opts.ignoreUnknownFields, false); + if (enumValue === tokenNull) { + msg.clear(field); + } + else if (enumValue !== tokenIgnoredUnknownEnum) { + msg.set(field, enumValue); + } +} +function readScalarField(msg, field, json) { + const scalarValue = scalarFromJson(field, json, false); + if (scalarValue === tokenNull) { + msg.clear(field); + } + else { + msg.set(field, scalarValue); + } +} +const tokenIgnoredUnknownEnum = Symbol(); +function readEnum(desc, json, ignoreUnknownFields, nullAsZeroValue) { + if (json === null) { + if (desc.typeName == "google.protobuf.NullValue") { + return 0; // google.protobuf.NullValue.NULL_VALUE = 0 + } + return nullAsZeroValue ? desc.values[0].number : tokenNull; + } + switch (typeof json) { + case "number": + if (Number.isInteger(json)) { + return json; + } + break; + case "string": + const value = desc.values.find((ev) => ev.name === json); + if (value !== undefined) { + return value.number; + } + if (ignoreUnknownFields) { + return tokenIgnoredUnknownEnum; + } + break; + } + throw new Error(`cannot decode ${desc} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`); +} +const tokenNull = Symbol(); +function scalarFromJson(field, json, nullAsZeroValue) { + if (json === null) { + if (nullAsZeroValue) { + return (0, scalar_js_1.scalarZeroValue)(field.scalar, false); + } + return tokenNull; + } + // int64, sfixed64, sint64, fixed64, uint64: Reflect supports string and number. + // string, bool: Supported by reflect. + switch (field.scalar) { + // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity". + // Either numbers or strings are accepted. Exponent notation is also accepted. + case descriptors_js_1.ScalarType.DOUBLE: + case descriptors_js_1.ScalarType.FLOAT: + if (json === "NaN") + return NaN; + if (json === "Infinity") + return Number.POSITIVE_INFINITY; + if (json === "-Infinity") + return Number.NEGATIVE_INFINITY; + if (typeof json == "number") { + if (Number.isNaN(json)) { + // NaN must be encoded with string constants + throw new error_js_1.FieldError(field, "unexpected NaN number"); + } + if (!Number.isFinite(json)) { + // Infinity must be encoded with string constants + throw new error_js_1.FieldError(field, "unexpected infinite number"); + } + break; + } + if (typeof json == "string") { + if (json === "") { + // empty string is not a number + break; + } + if (json.trim().length !== json.length) { + // extra whitespace + break; + } + const float = Number(json); + if (!Number.isFinite(float)) { + // Infinity and NaN must be encoded with string constants + break; + } + return float; + } + break; + // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted. + case descriptors_js_1.ScalarType.INT32: + case descriptors_js_1.ScalarType.FIXED32: + case descriptors_js_1.ScalarType.SFIXED32: + case descriptors_js_1.ScalarType.SINT32: + case descriptors_js_1.ScalarType.UINT32: + return int32FromJson(json); + // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings. + // Either standard or URL-safe base64 encoding with/without paddings are accepted. + case descriptors_js_1.ScalarType.BYTES: + if (typeof json == "string") { + if (json === "") { + return new Uint8Array(0); + } + try { + return (0, base64_encoding_js_1.base64Decode)(json); + } + catch (e) { + const message = e instanceof Error ? e.message : String(e); + throw new error_js_1.FieldError(field, message); + } + } + break; + } + return json; +} +/** + * Try to parse a JSON value to a map key for the reflect API. + * + * Returns the input if the JSON value cannot be converted. + */ +function mapKeyFromJson(type, json) { + switch (type) { + case descriptors_js_1.ScalarType.BOOL: + switch (json) { + case "true": + return true; + case "false": + return false; + } + return json; + case descriptors_js_1.ScalarType.INT32: + case descriptors_js_1.ScalarType.FIXED32: + case descriptors_js_1.ScalarType.UINT32: + case descriptors_js_1.ScalarType.SFIXED32: + case descriptors_js_1.ScalarType.SINT32: + return int32FromJson(json); + default: + return json; + } +} +/** + * Try to parse a JSON value to a 32-bit integer for the reflect API. + * + * Returns the input if the JSON value cannot be converted. + */ +function int32FromJson(json) { + if (typeof json == "string") { + if (json === "") { + // empty string is not a number + return json; + } + if (json.trim().length !== json.length) { + // extra whitespace + return json; + } + const num = Number(json); + if (Number.isNaN(num)) { + // not a number + return json; + } + return num; + } + return json; +} +function parseJsonString(jsonString, typeName) { + try { + return JSON.parse(jsonString); + } + catch (e) { + const message = e instanceof Error ? e.message : String(e); + throw new Error(`cannot decode message ${typeName} from JSON: ${message}`, + // @ts-expect-error we use the ES2022 error CTOR option "cause" for better stack traces + { cause: e }); + } +} +function tryWktFromJson(msg, jsonValue, opts) { + if (!msg.desc.typeName.startsWith("google.protobuf.")) { + return false; + } + switch (msg.desc.typeName) { + case "google.protobuf.Any": + anyFromJson(msg.message, jsonValue, opts); + return true; + case "google.protobuf.Timestamp": + timestampFromJson(msg.message, jsonValue); + return true; + case "google.protobuf.Duration": + durationFromJson(msg.message, jsonValue); + return true; + case "google.protobuf.FieldMask": + fieldMaskFromJson(msg.message, jsonValue); + return true; + case "google.protobuf.Struct": + structFromJson(msg.message, jsonValue); + return true; + case "google.protobuf.Value": + valueFromJson(msg.message, jsonValue); + return true; + case "google.protobuf.ListValue": + listValueFromJson(msg.message, jsonValue); + return true; + default: + if ((0, index_js_1.isWrapperDesc)(msg.desc)) { + const valueField = msg.desc.fields[0]; + if (jsonValue === null) { + msg.clear(valueField); + } + else { + msg.set(valueField, scalarFromJson(valueField, jsonValue, true)); + } + return true; + } + return false; + } +} +function anyFromJson(any, json, opts) { + var _a; + if (json === null || Array.isArray(json) || typeof json != "object") { + throw new Error(`cannot decode message ${any.$typeName} from JSON: expected object but got ${(0, reflect_check_js_1.formatVal)(json)}`); + } + if (Object.keys(json).length == 0) { + return; + } + const typeUrl = json["@type"]; + if (typeof typeUrl != "string" || typeUrl == "") { + throw new Error(`cannot decode message ${any.$typeName} from JSON: "@type" is empty`); + } + const typeName = typeUrl.includes("/") + ? typeUrl.substring(typeUrl.lastIndexOf("/") + 1) + : typeUrl; + if (!typeName.length) { + throw new Error(`cannot decode message ${any.$typeName} from JSON: "@type" is invalid`); + } + const desc = (_a = opts.registry) === null || _a === void 0 ? void 0 : _a.getMessage(typeName); + if (!desc) { + throw new Error(`cannot decode message ${any.$typeName} from JSON: ${typeUrl} is not in the type registry`); + } + const msg = (0, reflect_js_1.reflect)(desc); + if (typeName.startsWith("google.protobuf.") && + Object.prototype.hasOwnProperty.call(json, "value")) { + const value = json.value; + readMessage(msg, value, opts); + } + else { + const copy = Object.assign({}, json); + // biome-ignore lint/performance/noDelete: + delete copy["@type"]; + readMessage(msg, copy, opts); + } + (0, index_js_1.anyPack)(msg.desc, msg.message, any); +} +function timestampFromJson(timestamp, json) { + if (typeof json !== "string") { + throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`); + } + const matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\.([0-9]{1,9}))?(?:Z|([+-][0-9][0-9]:[0-9][0-9]))$/); + if (!matches) { + throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: invalid RFC 3339 string`); + } + const ms = Date.parse( + // biome-ignore format: want this to read well + matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z")); + if (Number.isNaN(ms)) { + throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: invalid RFC 3339 string`); + } + if (ms < Date.parse("0001-01-01T00:00:00Z") || + ms > Date.parse("9999-12-31T23:59:59Z")) { + throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`); + } + timestamp.seconds = proto_int64_js_1.protoInt64.parse(ms / 1000); + timestamp.nanos = 0; + if (matches[7]) { + timestamp.nanos = + parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) - + 1000000000; + } +} +function durationFromJson(duration, json) { + if (typeof json !== "string") { + throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`); + } + const match = json.match(/^(-?[0-9]+)(?:\.([0-9]+))?s/); + if (match === null) { + throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`); + } + const longSeconds = Number(match[1]); + if (longSeconds > 315576000000 || longSeconds < -315576000000) { + throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`); + } + duration.seconds = proto_int64_js_1.protoInt64.parse(longSeconds); + if (typeof match[2] !== "string") { + return; + } + const nanosStr = match[2] + "0".repeat(9 - match[2].length); + duration.nanos = parseInt(nanosStr); + if (longSeconds < 0 || Object.is(longSeconds, -0)) { + duration.nanos = -duration.nanos; + } +} +function fieldMaskFromJson(fieldMask, json) { + if (typeof json !== "string") { + throw new Error(`cannot decode message ${fieldMask.$typeName} from JSON: ${(0, reflect_check_js_1.formatVal)(json)}`); + } + if (json === "") { + return; + } + function camelToSnake(str) { + if (str.includes("_")) { + throw new Error(`cannot decode message ${fieldMask.$typeName} from JSON: path names must be lowerCamelCase`); + } + const sc = str.replace(/[A-Z]/g, (letter) => "_" + letter.toLowerCase()); + return sc[0] === "_" ? sc.substring(1) : sc; + } + fieldMask.paths = json.split(",").map(camelToSnake); +} +function structFromJson(struct, json) { + if (typeof json != "object" || json == null || Array.isArray(json)) { + throw new Error(`cannot decode message ${struct.$typeName} from JSON ${(0, reflect_check_js_1.formatVal)(json)}`); + } + for (const [k, v] of Object.entries(json)) { + const parsedV = (0, create_js_1.create)(index_js_1.ValueSchema); + valueFromJson(parsedV, v); + struct.fields[k] = parsedV; + } +} +function valueFromJson(value, json) { + switch (typeof json) { + case "number": + value.kind = { case: "numberValue", value: json }; + break; + case "string": + value.kind = { case: "stringValue", value: json }; + break; + case "boolean": + value.kind = { case: "boolValue", value: json }; + break; + case "object": + if (json === null) { + value.kind = { case: "nullValue", value: index_js_1.NullValue.NULL_VALUE }; + } + else if (Array.isArray(json)) { + const listValue = (0, create_js_1.create)(index_js_1.ListValueSchema); + listValueFromJson(listValue, json); + value.kind = { case: "listValue", value: listValue }; + } + else { + const struct = (0, create_js_1.create)(index_js_1.StructSchema); + structFromJson(struct, json); + value.kind = { case: "structValue", value: struct }; + } + break; + default: + throw new Error(`cannot decode message ${value.$typeName} from JSON ${(0, reflect_check_js_1.formatVal)(json)}`); + } + return value; +} +function listValueFromJson(listValue, json) { + if (!Array.isArray(json)) { + throw new Error(`cannot decode message ${listValue.$typeName} from JSON ${(0, reflect_check_js_1.formatVal)(json)}`); + } + for (const e of json) { + const value = (0, create_js_1.create)(index_js_1.ValueSchema); + valueFromJson(value, e); + listValue.values.push(value); + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/index.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7a23115160415ba30f14f8cfe66be6bc92bb2a32 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/index.d.ts @@ -0,0 +1,18 @@ +export * from "./types.js"; +export * from "./is-message.js"; +export * from "./create.js"; +export * from "./clone.js"; +export * from "./descriptors.js"; +export * from "./equals.js"; +export * from "./fields.js"; +export * from "./registry.js"; +export type { JsonValue, JsonObject } from "./json-value.js"; +export { toBinary } from "./to-binary.js"; +export type { BinaryWriteOptions } from "./to-binary.js"; +export { fromBinary, mergeFromBinary } from "./from-binary.js"; +export type { BinaryReadOptions } from "./from-binary.js"; +export * from "./to-json.js"; +export * from "./from-json.js"; +export * from "./merge.js"; +export { hasExtension, getExtension, setExtension, clearExtension, hasOption, getOption, } from "./extensions.js"; +export * from "./proto-int64.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/index.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/index.js new file mode 100644 index 0000000000000000000000000000000000000000..c32f6ff6011a81ef833ba847e42d9751565825c2 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/index.js @@ -0,0 +1,54 @@ +"use strict"; +// Copyright 2021-2025 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. +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getOption = exports.hasOption = exports.clearExtension = exports.setExtension = exports.getExtension = exports.hasExtension = exports.mergeFromBinary = exports.fromBinary = exports.toBinary = void 0; +__exportStar(require("./types.js"), exports); +__exportStar(require("./is-message.js"), exports); +__exportStar(require("./create.js"), exports); +__exportStar(require("./clone.js"), exports); +__exportStar(require("./descriptors.js"), exports); +__exportStar(require("./equals.js"), exports); +__exportStar(require("./fields.js"), exports); +__exportStar(require("./registry.js"), exports); +var to_binary_js_1 = require("./to-binary.js"); +Object.defineProperty(exports, "toBinary", { enumerable: true, get: function () { return to_binary_js_1.toBinary; } }); +var from_binary_js_1 = require("./from-binary.js"); +Object.defineProperty(exports, "fromBinary", { enumerable: true, get: function () { return from_binary_js_1.fromBinary; } }); +Object.defineProperty(exports, "mergeFromBinary", { enumerable: true, get: function () { return from_binary_js_1.mergeFromBinary; } }); +__exportStar(require("./to-json.js"), exports); +__exportStar(require("./from-json.js"), exports); +__exportStar(require("./merge.js"), exports); +var extensions_js_1 = require("./extensions.js"); +Object.defineProperty(exports, "hasExtension", { enumerable: true, get: function () { return extensions_js_1.hasExtension; } }); +Object.defineProperty(exports, "getExtension", { enumerable: true, get: function () { return extensions_js_1.getExtension; } }); +Object.defineProperty(exports, "setExtension", { enumerable: true, get: function () { return extensions_js_1.setExtension; } }); +Object.defineProperty(exports, "clearExtension", { enumerable: true, get: function () { return extensions_js_1.clearExtension; } }); +Object.defineProperty(exports, "hasOption", { enumerable: true, get: function () { return extensions_js_1.hasOption; } }); +Object.defineProperty(exports, "getOption", { enumerable: true, get: function () { return extensions_js_1.getOption; } }); +__exportStar(require("./proto-int64.js"), exports); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/is-message.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/is-message.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..085782d5d1d8ed73a4f6cebda7348822bcddab04 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/is-message.d.ts @@ -0,0 +1,7 @@ +import type { MessageShape } from "./types.js"; +import type { DescMessage } from "./descriptors.js"; +/** + * Determine whether the given `arg` is a message. + * If `desc` is set, determine whether `arg` is this specific message. + */ +export declare function isMessage(arg: unknown, schema?: Desc): arg is MessageShape; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/is-message.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/is-message.js new file mode 100644 index 0000000000000000000000000000000000000000..438a86b2f937c6ec7df83c31832e537acfbe3ad6 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/is-message.js @@ -0,0 +1,33 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isMessage = isMessage; +/** + * Determine whether the given `arg` is a message. + * If `desc` is set, determine whether `arg` is this specific message. + */ +function isMessage(arg, schema) { + const isMessage = arg !== null && + typeof arg == "object" && + "$typeName" in arg && + typeof arg.$typeName == "string"; + if (!isMessage) { + return false; + } + if (schema === undefined) { + return true; + } + return schema.typeName === arg.$typeName; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/json-value.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/json-value.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3857eb8d4e19a46687b68f041fdddb47824f680a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/json-value.d.ts @@ -0,0 +1,16 @@ +/** + * Represents any possible JSON value: + * - number + * - string + * - boolean + * - null + * - object (with any JSON value as property) + * - array (with any JSON value as element) + */ +export type JsonValue = number | string | boolean | null | JsonObject | JsonValue[]; +/** + * Represents a JSON object. + */ +export type JsonObject = { + [k: string]: JsonValue; +}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/json-value.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/json-value.js new file mode 100644 index 0000000000000000000000000000000000000000..c14a1eed2ff16dd436dca87983df11fee4697f1d --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/json-value.js @@ -0,0 +1,15 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/merge.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/merge.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..aad01ed042172fd239ff8bbe0fb971604a4bab0a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/merge.d.ts @@ -0,0 +1,13 @@ +import type { MessageShape } from "./types.js"; +import type { DescMessage } from "./descriptors.js"; +/** + * Merge message `source` into message `target`, following Protobuf semantics. + * + * This is the same as serializing the source message, then deserializing it + * into the target message via `mergeFromBinary()`, with one difference: + * While serialization will create a copy of all values, `merge()` will copy + * the reference for `bytes` and messages. + * + * Also see https://protobuf.com/docs/language-spec#merging-protobuf-messages + */ +export declare function merge(schema: Desc, target: MessageShape, source: MessageShape): void; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/merge.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/merge.js new file mode 100644 index 0000000000000000000000000000000000000000..be7599e1235d4b1712e4f86a4ce0aaab46880c81 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/merge.js @@ -0,0 +1,70 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.merge = merge; +const reflect_js_1 = require("./reflect/reflect.js"); +/** + * Merge message `source` into message `target`, following Protobuf semantics. + * + * This is the same as serializing the source message, then deserializing it + * into the target message via `mergeFromBinary()`, with one difference: + * While serialization will create a copy of all values, `merge()` will copy + * the reference for `bytes` and messages. + * + * Also see https://protobuf.com/docs/language-spec#merging-protobuf-messages + */ +function merge(schema, target, source) { + reflectMerge((0, reflect_js_1.reflect)(schema, target), (0, reflect_js_1.reflect)(schema, source)); +} +function reflectMerge(target, source) { + var _a; + var _b; + const sourceUnknown = source.message.$unknown; + if (sourceUnknown !== undefined && sourceUnknown.length > 0) { + (_a = (_b = target.message).$unknown) !== null && _a !== void 0 ? _a : (_b.$unknown = []); + target.message.$unknown.push(...sourceUnknown); + } + for (const f of target.fields) { + if (!source.isSet(f)) { + continue; + } + switch (f.fieldKind) { + case "scalar": + case "enum": + target.set(f, source.get(f)); + break; + case "message": + if (target.isSet(f)) { + reflectMerge(target.get(f), source.get(f)); + } + else { + target.set(f, source.get(f)); + } + break; + case "list": + const list = target.get(f); + for (const e of source.get(f)) { + list.add(e); + } + break; + case "map": + const map = target.get(f); + for (const [k, v] of source.get(f)) { + map.set(k, v); + } + break; + } + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/package.json b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/package.json new file mode 100644 index 0000000000000000000000000000000000000000..729ac4d93b7f2d9be36b44525f02ff6555f9383a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/package.json @@ -0,0 +1 @@ +{"type":"commonjs"} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/proto-int64.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/proto-int64.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3eaf231a9724e09334df9c3b1c4dc152c05dd7e7 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/proto-int64.d.ts @@ -0,0 +1,98 @@ +/** + * Int64Support for the current environment. + */ +export declare const protoInt64: Int64Support; +/** + * We use the `bigint` primitive to represent 64-bit integral types. If bigint + * is unavailable, we fall back to a string representation, which means that + * all values typed as `bigint` will actually be strings. + * + * If your code is intended to run in an environment where bigint may be + * unavailable, it must handle both the bigint and the string representation. + * For presenting values, this is straight-forward with implicit or explicit + * conversion to string: + * + * ```ts + * let el = document.createElement("span"); + * el.innerText = message.int64Field; // assuming a protobuf int64 field + * + * console.log(`int64: ${message.int64Field}`); + * + * let str: string = message.int64Field.toString(); + * ``` + * + * If you need to manipulate 64-bit integral values and are sure the values + * can be safely represented as an IEEE-754 double precision number, you can + * convert to a JavaScript Number: + * + * ```ts + * console.log(message.int64Field.toString()) + * let num = Number(message.int64Field); + * num = num + 1; + * message.int64Field = protoInt64.parse(num); + * ``` + * + * If you need to manipulate 64-bit integral values that are outside the + * range of safe representation as a JavaScript Number, we recommend you + * use a third party library, for example the npm package "long": + * + * ```ts + * // convert the field value to a Long + * const bits = protoInt64.enc(message.int64Field); + * const longValue = Long.fromBits(bits.lo, bits.hi); + * + * // perform arithmetic + * const longResult = longValue.subtract(1); + * + * // set the result in the field + * message.int64Field = protoInt64.dec(longResult.low, longResult.high); + * + * // Assuming int64Field contains 9223372036854775807: + * console.log(message.int64Field); // 9223372036854775806 + * ``` + */ +interface Int64Support { + /** + * 0n if bigint is available, "0" if unavailable. + */ + readonly zero: bigint; + /** + * Is bigint available? + */ + readonly supported: boolean; + /** + * Parse a signed 64-bit integer. + * Returns a bigint if available, a string otherwise. + */ + parse(value: string | number | bigint): bigint; + /** + * Parse an unsigned 64-bit integer. + * Returns a bigint if available, a string otherwise. + */ + uParse(value: string | number | bigint): bigint; + /** + * Convert a signed 64-bit integral value to a two's complement. + */ + enc(value: string | number | bigint): { + lo: number; + hi: number; + }; + /** + * Convert an unsigned 64-bit integral value to a two's complement. + */ + uEnc(value: string | number | bigint): { + lo: number; + hi: number; + }; + /** + * Convert a two's complement to a signed 64-bit integral value. + * Returns a bigint if available, a string otherwise. + */ + dec(lo: number, hi: number): bigint; + /** + * Convert a two's complement to an unsigned 64-bit integral value. + * Returns a bigint if available, a string otherwise. + */ + uDec(lo: number, hi: number): bigint; +} +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/proto-int64.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/proto-int64.js new file mode 100644 index 0000000000000000000000000000000000000000..0b44018e2dc5855f7acab8004cce380845f73db1 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/proto-int64.js @@ -0,0 +1,129 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.protoInt64 = void 0; +const varint_js_1 = require("./wire/varint.js"); +/** + * Int64Support for the current environment. + */ +exports.protoInt64 = makeInt64Support(); +function makeInt64Support() { + const dv = new DataView(new ArrayBuffer(8)); + // note that Safari 14 implements BigInt, but not the DataView methods + const ok = typeof BigInt === "function" && + typeof dv.getBigInt64 === "function" && + typeof dv.getBigUint64 === "function" && + typeof dv.setBigInt64 === "function" && + typeof dv.setBigUint64 === "function" && + (typeof process != "object" || + typeof process.env != "object" || + process.env.BUF_BIGINT_DISABLE !== "1"); + if (ok) { + const MIN = BigInt("-9223372036854775808"); + const MAX = BigInt("9223372036854775807"); + const UMIN = BigInt("0"); + const UMAX = BigInt("18446744073709551615"); + return { + zero: BigInt(0), + supported: true, + parse(value) { + const bi = typeof value == "bigint" ? value : BigInt(value); + if (bi > MAX || bi < MIN) { + throw new Error(`invalid int64: ${value}`); + } + return bi; + }, + uParse(value) { + const bi = typeof value == "bigint" ? value : BigInt(value); + if (bi > UMAX || bi < UMIN) { + throw new Error(`invalid uint64: ${value}`); + } + return bi; + }, + enc(value) { + dv.setBigInt64(0, this.parse(value), true); + return { + lo: dv.getInt32(0, true), + hi: dv.getInt32(4, true), + }; + }, + uEnc(value) { + dv.setBigInt64(0, this.uParse(value), true); + return { + lo: dv.getInt32(0, true), + hi: dv.getInt32(4, true), + }; + }, + dec(lo, hi) { + dv.setInt32(0, lo, true); + dv.setInt32(4, hi, true); + return dv.getBigInt64(0, true); + }, + uDec(lo, hi) { + dv.setInt32(0, lo, true); + dv.setInt32(4, hi, true); + return dv.getBigUint64(0, true); + }, + }; + } + return { + zero: "0", + supported: false, + parse(value) { + if (typeof value != "string") { + value = value.toString(); + } + assertInt64String(value); + return value; + }, + uParse(value) { + if (typeof value != "string") { + value = value.toString(); + } + assertUInt64String(value); + return value; + }, + enc(value) { + if (typeof value != "string") { + value = value.toString(); + } + assertInt64String(value); + return (0, varint_js_1.int64FromString)(value); + }, + uEnc(value) { + if (typeof value != "string") { + value = value.toString(); + } + assertUInt64String(value); + return (0, varint_js_1.int64FromString)(value); + }, + dec(lo, hi) { + return (0, varint_js_1.int64ToString)(lo, hi); + }, + uDec(lo, hi) { + return (0, varint_js_1.uInt64ToString)(lo, hi); + }, + }; +} +function assertInt64String(value) { + if (!/^-?[0-9]+$/.test(value)) { + throw new Error("invalid int64: " + value); + } +} +function assertUInt64String(value) { + if (!/^[0-9]+$/.test(value)) { + throw new Error("invalid uint64: " + value); + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/error.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/error.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c6bf1db0e4431a962daa8125489afad049029ea2 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/error.d.ts @@ -0,0 +1,9 @@ +import type { DescField, DescOneof } from "../descriptors.js"; +declare const errorNames: string[]; +export declare class FieldError extends Error { + readonly name: (typeof errorNames)[number]; + constructor(fieldOrOneof: DescField | DescOneof, message: string, name?: (typeof errorNames)[number]); + readonly field: () => DescField | DescOneof; +} +export declare function isFieldError(arg: unknown): arg is FieldError; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/error.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/error.js new file mode 100644 index 0000000000000000000000000000000000000000..79bdb733baead2c10fea5bff48a438747ea7dc5a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/error.js @@ -0,0 +1,36 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.FieldError = void 0; +exports.isFieldError = isFieldError; +const errorNames = [ + "FieldValueInvalidError", + "FieldListRangeError", + "ForeignFieldError", +]; +class FieldError extends Error { + constructor(fieldOrOneof, message, name = "FieldValueInvalidError") { + super(message); + this.name = name; + this.field = () => fieldOrOneof; + } +} +exports.FieldError = FieldError; +function isFieldError(arg) { + return (arg instanceof Error && + errorNames.includes(arg.name) && + "field" in arg && + typeof arg.field == "function"); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/guard.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/guard.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c53aeb23407a24e8f6bd7949870f36b23a2148a9 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/guard.d.ts @@ -0,0 +1,20 @@ +import type { Message } from "../types.js"; +import type { ScalarValue } from "./scalar.js"; +import type { ReflectList, ReflectMap, ReflectMessage } from "./reflect-types.js"; +import type { DescField, DescMessage } from "../descriptors.js"; +export declare function isObject(arg: unknown): arg is Record; +export declare function isOneofADT(arg: unknown): arg is OneofADT; +export type OneofADT = { + case: undefined; + value?: undefined; +} | { + case: string; + value: Message | ScalarValue; +}; +export declare function isReflectList(arg: unknown, field?: DescField & { + fieldKind: "list"; +}): arg is ReflectList; +export declare function isReflectMap(arg: unknown, field?: DescField & { + fieldKind: "map"; +}): arg is ReflectMap; +export declare function isReflectMessage(arg: unknown, messageDesc?: DescMessage): arg is ReflectMessage; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/guard.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/guard.js new file mode 100644 index 0000000000000000000000000000000000000000..ebf01d473a8d192da82bb702ccee1172e650afe6 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/guard.js @@ -0,0 +1,78 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isObject = isObject; +exports.isOneofADT = isOneofADT; +exports.isReflectList = isReflectList; +exports.isReflectMap = isReflectMap; +exports.isReflectMessage = isReflectMessage; +const unsafe_js_1 = require("./unsafe.js"); +function isObject(arg) { + return arg !== null && typeof arg == "object" && !Array.isArray(arg); +} +function isOneofADT(arg) { + return (arg !== null && + typeof arg == "object" && + "case" in arg && + ((typeof arg.case == "string" && "value" in arg && arg.value != null) || + (arg.case === undefined && + (!("value" in arg) || arg.value === undefined)))); +} +function isReflectList(arg, field) { + var _a, _b, _c, _d; + if (isObject(arg) && + unsafe_js_1.unsafeLocal in arg && + "add" in arg && + "field" in arg && + typeof arg.field == "function") { + if (field !== undefined) { + const a = field; + const b = arg.field(); + return (a.listKind == b.listKind && + a.scalar === b.scalar && + ((_a = a.message) === null || _a === void 0 ? void 0 : _a.typeName) === ((_b = b.message) === null || _b === void 0 ? void 0 : _b.typeName) && + ((_c = a.enum) === null || _c === void 0 ? void 0 : _c.typeName) === ((_d = b.enum) === null || _d === void 0 ? void 0 : _d.typeName)); + } + return true; + } + return false; +} +function isReflectMap(arg, field) { + var _a, _b, _c, _d; + if (isObject(arg) && + unsafe_js_1.unsafeLocal in arg && + "has" in arg && + "field" in arg && + typeof arg.field == "function") { + if (field !== undefined) { + const a = field, b = arg.field(); + return (a.mapKey === b.mapKey && + a.mapKind == b.mapKind && + a.scalar === b.scalar && + ((_a = a.message) === null || _a === void 0 ? void 0 : _a.typeName) === ((_b = b.message) === null || _b === void 0 ? void 0 : _b.typeName) && + ((_c = a.enum) === null || _c === void 0 ? void 0 : _c.typeName) === ((_d = b.enum) === null || _d === void 0 ? void 0 : _d.typeName)); + } + return true; + } + return false; +} +function isReflectMessage(arg, messageDesc) { + return (isObject(arg) && + unsafe_js_1.unsafeLocal in arg && + "desc" in arg && + isObject(arg.desc) && + arg.desc.kind === "message" && + (messageDesc === undefined || arg.desc.typeName == messageDesc.typeName)); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/index.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..97a71306f22a348c82e645555d5ed761210fffb3 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/index.d.ts @@ -0,0 +1,8 @@ +export * from "./error.js"; +export * from "./names.js"; +export * from "./nested-types.js"; +export * from "./reflect.js"; +export * from "./reflect-types.js"; +export * from "./scalar.js"; +export * from "./path.js"; +export { isReflectList, isReflectMap, isReflectMessage } from "./guard.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/index.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/index.js new file mode 100644 index 0000000000000000000000000000000000000000..59c48ca6d5977cd214fd54e53f6b8197bc9d7727 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/index.js @@ -0,0 +1,41 @@ +"use strict"; +// Copyright 2021-2025 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. +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isReflectMessage = exports.isReflectMap = exports.isReflectList = void 0; +__exportStar(require("./error.js"), exports); +__exportStar(require("./names.js"), exports); +__exportStar(require("./nested-types.js"), exports); +__exportStar(require("./reflect.js"), exports); +__exportStar(require("./reflect-types.js"), exports); +__exportStar(require("./scalar.js"), exports); +__exportStar(require("./path.js"), exports); +var guard_js_1 = require("./guard.js"); +Object.defineProperty(exports, "isReflectList", { enumerable: true, get: function () { return guard_js_1.isReflectList; } }); +Object.defineProperty(exports, "isReflectMap", { enumerable: true, get: function () { return guard_js_1.isReflectMap; } }); +Object.defineProperty(exports, "isReflectMessage", { enumerable: true, get: function () { return guard_js_1.isReflectMessage; } }); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/names.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/names.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3824c63dbbaf687e4dfc9e57be050771832d4982 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/names.d.ts @@ -0,0 +1,19 @@ +import type { AnyDesc } from "../descriptors.js"; +/** + * Return a fully-qualified name for a Protobuf descriptor. + * For a file descriptor, return the original file path. + * + * See https://protobuf.com/docs/language-spec#fully-qualified-names + */ +export declare function qualifiedName(desc: AnyDesc): string; +/** + * Converts snake_case to protoCamelCase according to the convention + * used by protoc to convert a field name to a JSON name. + */ +export declare function protoCamelCase(snakeCase: string): string; +/** + * Escapes names that are reserved for ECMAScript built-in object properties. + * + * Also see safeIdentifier() from @bufbuild/protoplugin. + */ +export declare function safeObjectProperty(name: string): string; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/names.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/names.js new file mode 100644 index 0000000000000000000000000000000000000000..873e694eb2420248200b2be820a556f035221bdc --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/names.js @@ -0,0 +1,101 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.qualifiedName = qualifiedName; +exports.protoCamelCase = protoCamelCase; +exports.safeObjectProperty = safeObjectProperty; +/** + * Return a fully-qualified name for a Protobuf descriptor. + * For a file descriptor, return the original file path. + * + * See https://protobuf.com/docs/language-spec#fully-qualified-names + */ +function qualifiedName(desc) { + switch (desc.kind) { + case "field": + case "oneof": + case "rpc": + return desc.parent.typeName + "." + desc.name; + case "enum_value": { + const p = desc.parent.parent + ? desc.parent.parent.typeName + : desc.parent.file.proto.package; + return p + (p.length > 0 ? "." : "") + desc.name; + } + case "service": + case "message": + case "enum": + case "extension": + return desc.typeName; + case "file": + return desc.proto.name; + } +} +/** + * Converts snake_case to protoCamelCase according to the convention + * used by protoc to convert a field name to a JSON name. + */ +function protoCamelCase(snakeCase) { + let capNext = false; + const b = []; + for (let i = 0; i < snakeCase.length; i++) { + let c = snakeCase.charAt(i); + switch (c) { + case "_": + capNext = true; + break; + case "0": + case "1": + case "2": + case "3": + case "4": + case "5": + case "6": + case "7": + case "8": + case "9": + b.push(c); + capNext = false; + break; + default: + if (capNext) { + capNext = false; + c = c.toUpperCase(); + } + b.push(c); + break; + } + } + return b.join(""); +} +/** + * Names that cannot be used for object properties because they are reserved + * by built-in JavaScript properties. + */ +const reservedObjectProperties = new Set([ + // names reserved by JavaScript + "constructor", + "toString", + "toJSON", + "valueOf", +]); +/** + * Escapes names that are reserved for ECMAScript built-in object properties. + * + * Also see safeIdentifier() from @bufbuild/protoplugin. + */ +function safeObjectProperty(name) { + return reservedObjectProperties.has(name) ? name + "$" : name; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/nested-types.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/nested-types.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3817501c613503736031d0ecae80582692a5f0ca --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/nested-types.d.ts @@ -0,0 +1,35 @@ +import type { AnyDesc, DescEnum, DescExtension, DescFile, DescMessage, DescService } from "../descriptors.js"; +/** + * Iterate over all types - enumerations, extensions, services, messages - + * and enumerations, extensions and messages nested in messages. + */ +export declare function nestedTypes(desc: DescFile | DescMessage): Iterable; +/** + * Iterate over types referenced by fields of the given message. + * + * For example: + * + * ```proto + * syntax="proto3"; + * + * message Example { + * Msg singular = 1; + * repeated Level list = 2; + * } + * + * message Msg {} + * + * enum Level { + * LEVEL_UNSPECIFIED = 0; + * } + * ``` + * + * The message Example references the message Msg, and the enum Level. + */ +export declare function usedTypes(descMessage: DescMessage): Iterable; +/** + * Returns the ancestors of a given Protobuf element, up to the file. + */ +export declare function parentTypes(desc: AnyDesc): Parent[]; +type Parent = DescFile | DescEnum | DescMessage | DescService; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/nested-types.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/nested-types.js new file mode 100644 index 0000000000000000000000000000000000000000..330e5cbb35fb1a1411061de6931c9e220f6eb9ea --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/nested-types.js @@ -0,0 +1,110 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.nestedTypes = nestedTypes; +exports.usedTypes = usedTypes; +exports.parentTypes = parentTypes; +/** + * Iterate over all types - enumerations, extensions, services, messages - + * and enumerations, extensions and messages nested in messages. + */ +function* nestedTypes(desc) { + switch (desc.kind) { + case "file": + for (const message of desc.messages) { + yield message; + yield* nestedTypes(message); + } + yield* desc.enums; + yield* desc.services; + yield* desc.extensions; + break; + case "message": + for (const message of desc.nestedMessages) { + yield message; + yield* nestedTypes(message); + } + yield* desc.nestedEnums; + yield* desc.nestedExtensions; + break; + } +} +/** + * Iterate over types referenced by fields of the given message. + * + * For example: + * + * ```proto + * syntax="proto3"; + * + * message Example { + * Msg singular = 1; + * repeated Level list = 2; + * } + * + * message Msg {} + * + * enum Level { + * LEVEL_UNSPECIFIED = 0; + * } + * ``` + * + * The message Example references the message Msg, and the enum Level. + */ +function usedTypes(descMessage) { + return usedTypesInternal(descMessage, new Set()); +} +function* usedTypesInternal(descMessage, seen) { + var _a, _b; + for (const field of descMessage.fields) { + const ref = (_b = (_a = field.enum) !== null && _a !== void 0 ? _a : field.message) !== null && _b !== void 0 ? _b : undefined; + if (!ref || seen.has(ref.typeName)) { + continue; + } + seen.add(ref.typeName); + yield ref; + if (ref.kind == "message") { + yield* usedTypesInternal(ref, seen); + } + } +} +/** + * Returns the ancestors of a given Protobuf element, up to the file. + */ +function parentTypes(desc) { + const parents = []; + while (desc.kind !== "file") { + const p = parent(desc); + desc = p; + parents.push(p); + } + return parents; +} +function parent(desc) { + var _a; + switch (desc.kind) { + case "enum_value": + case "field": + case "oneof": + case "rpc": + return desc.parent; + case "service": + return desc.file; + case "extension": + case "enum": + case "message": + return (_a = desc.parent) !== null && _a !== void 0 ? _a : desc.file; + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/path.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/path.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..cb352b2fe3fdb18c32fbf7d5dd48d817be5f2d1d --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/path.d.ts @@ -0,0 +1,107 @@ +import { type DescExtension, type DescField, type DescMessage, type DescOneof } from "../descriptors.js"; +import type { Registry } from "../registry.js"; +/** + * A path to a (nested) member of a Protobuf message, such as a field, oneof, + * extension, list element, or map entry. + * + * Note that we may add additional types to this union in the future to support + * more use cases. + */ +export type Path = (DescField | DescExtension | DescOneof | { + kind: "list_sub"; + index: number; +} | { + kind: "map_sub"; + key: string | number | bigint | boolean; +})[]; +/** + * Builds a Path. + */ +export type PathBuilder = { + /** + * The root message of the path. + */ + readonly schema: DescMessage; + /** + * Add field access. + * + * Throws an InvalidPathError if the field cannot be added to the path. + */ + field(field: DescField): PathBuilder; + /** + * Access a oneof. + * + * Throws an InvalidPathError if the oneof cannot be added to the path. + * + */ + oneof(oneof: DescOneof): PathBuilder; + /** + * Access an extension. + * + * Throws an InvalidPathError if the extension cannot be added to the path. + */ + extension(extension: DescExtension): PathBuilder; + /** + * Access a list field by index. + * + * Throws an InvalidPathError if the list access cannot be added to the path. + */ + list(index: number): PathBuilder; + /** + * Access a map field by key. + * + * Throws an InvalidPathError if the map access cannot be added to the path. + */ + map(key: string | number | bigint | boolean): PathBuilder; + /** + * Append a path. + * + * Throws an InvalidPathError if the path cannot be added. + */ + add(path: Path | PathBuilder): PathBuilder; + /** + * Return the path. + */ + toPath(): Path; + /** + * Create a copy of this builder. + */ + clone(): PathBuilder; + /** + * Get the current container - a list, map, or message. + */ + getLeft(): DescMessage | (DescField & { + fieldKind: "list"; + }) | (DescField & { + fieldKind: "map"; + }) | undefined; +}; +/** + * Create a PathBuilder. + */ +export declare function buildPath(schema: DescMessage): PathBuilder; +/** + * Parse a Path from a string. + * + * Throws an InvalidPathError if the path is invalid. + * + * Note that a Registry must be provided via the options argument to parse + * paths that refer to an extension. + */ +export declare function parsePath(schema: DescMessage, path: string, options?: { + registry?: Registry; +}): Path; +/** + * Stringify a path. + */ +export declare function pathToString(path: Path): string; +/** + * InvalidPathError is thrown for invalid Paths, for example during parsing from + * a string, or when a new Path is built. + */ +export declare class InvalidPathError extends Error { + name: string; + readonly schema: DescMessage; + readonly path: Path | string; + constructor(schema: DescMessage, message: string, path: string | Path); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/path.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/path.js new file mode 100644 index 0000000000000000000000000000000000000000..6acbebaf8273d6e96c1657fd9e0aa52456a0b840 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/path.js @@ -0,0 +1,376 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.InvalidPathError = void 0; +exports.buildPath = buildPath; +exports.parsePath = parsePath; +exports.pathToString = pathToString; +const descriptors_js_1 = require("../descriptors.js"); +/** + * Create a PathBuilder. + */ +function buildPath(schema) { + return new PathBuilderImpl(schema, schema, []); +} +/** + * Parse a Path from a string. + * + * Throws an InvalidPathError if the path is invalid. + * + * Note that a Registry must be provided via the options argument to parse + * paths that refer to an extension. + */ +function parsePath(schema, path, options) { + var _a, _b; + const builder = new PathBuilderImpl(schema, schema, []); + const err = (message, i) => new InvalidPathError(schema, message + " at column " + (i + 1), path); + for (let i = 0; i < path.length;) { + const token = nextToken(i, path); + const left = builder.getLeft(); + let right = undefined; + if ("field" in token) { + right = + (left === null || left === void 0 ? void 0 : left.kind) != "message" + ? undefined + : ((_a = left.fields.find((field) => field.name === token.field)) !== null && _a !== void 0 ? _a : left.oneofs.find((oneof) => oneof.name === token.field)); + if (!right) { + throw err(`Unknown field "${token.field}"`, i); + } + } + else if ("ext" in token) { + right = (_b = options === null || options === void 0 ? void 0 : options.registry) === null || _b === void 0 ? void 0 : _b.getExtension(token.ext); + if (!right) { + throw err(`Unknown extension "${token.ext}"`, i); + } + } + else if ("val" in token) { + // list or map + right = + (left === null || left === void 0 ? void 0 : left.kind) == "field" && + left.fieldKind == "list" && + typeof token.val == "bigint" + ? { kind: "list_sub", index: Number(token.val) } + : { kind: "map_sub", key: token.val }; + } + else if ("err" in token) { + throw err(token.err, token.i); + } + if (right) { + try { + builder.add([right]); + } + catch (e) { + throw err(e instanceof InvalidPathError ? e.message : String(e), i); + } + } + i = token.i; + } + return builder.toPath(); +} +/** + * Stringify a path. + */ +function pathToString(path) { + const str = []; + for (const ele of path) { + switch (ele.kind) { + case "field": + case "oneof": + if (str.length > 0) { + str.push("."); + } + str.push(ele.name); + break; + case "extension": + str.push("[", ele.typeName, "]"); + break; + case "list_sub": + str.push("[", ele.index, "]"); + break; + case "map_sub": + if (typeof ele.key == "string") { + str.push('["', ele.key + .split("\\") + .join("\\\\") + .split('"') + .join('\\"') + .split("\r") + .join("\\r") + .split("\n") + .join("\\n"), '"]'); + } + else { + str.push("[", ele.key, "]"); + } + break; + } + } + return str.join(""); +} +/** + * InvalidPathError is thrown for invalid Paths, for example during parsing from + * a string, or when a new Path is built. + */ +class InvalidPathError extends Error { + constructor(schema, message, path) { + super(message); + this.name = "InvalidPathError"; + this.schema = schema; + this.path = path; + // see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#example + Object.setPrototypeOf(this, new.target.prototype); + } +} +exports.InvalidPathError = InvalidPathError; +class PathBuilderImpl { + constructor(schema, left, path) { + this.schema = schema; + this.left = left; + this.path = path; + } + getLeft() { + return this.left; + } + field(field) { + return this.push(field); + } + oneof(oneof) { + return this.push(oneof); + } + extension(extension) { + return this.push(extension); + } + list(index) { + return this.push({ kind: "list_sub", index }); + } + map(key) { + return this.push({ kind: "map_sub", key }); + } + add(pathOrBuilder) { + const path = Array.isArray(pathOrBuilder) + ? pathOrBuilder + : pathOrBuilder.toPath(); + const l = this.path.length; + try { + for (const ele of path) { + this.push(ele); + } + } + catch (e) { + // undo pushes + this.path.splice(l); + throw e; + } + return this; + } + toPath() { + return this.path.concat(); + } + clone() { + return new PathBuilderImpl(this.schema, this.left, this.path.concat()); + } + push(ele) { + switch (ele.kind) { + case "field": + if (!this.left || + this.left.kind != "message" || + this.left.typeName != ele.parent.typeName) { + throw this.err("field access"); + } + this.path.push(ele); + this.left = + ele.fieldKind == "message" + ? ele.message + : ele.fieldKind == "list" || ele.fieldKind == "map" + ? ele + : undefined; + return this; + case "oneof": + if (!this.left || + this.left.kind != "message" || + this.left.typeName != ele.parent.typeName) { + throw this.err("oneof access"); + } + this.path.push(ele); + this.left = undefined; + return this; + case "extension": + if (!this.left || + this.left.kind != "message" || + this.left.typeName != ele.extendee.typeName) { + throw this.err("extension access"); + } + this.path.push(ele); + this.left = ele.fieldKind == "message" ? ele.message : undefined; + return this; + case "list_sub": + if (!this.left || + this.left.kind != "field" || + this.left.fieldKind != "list") { + throw this.err("list access"); + } + if (ele.index < 0 || !Number.isInteger(ele.index)) { + throw this.err("list index"); + } + this.path.push(ele); + this.left = + this.left.listKind == "message" ? this.left.message : undefined; + return this; + case "map_sub": + if (!this.left || + this.left.kind != "field" || + this.left.fieldKind != "map") { + throw this.err("map access"); + } + if (!checkKeyType(ele.key, this.left.mapKey)) { + throw this.err("map key"); + } + this.path.push(ele); + this.left = + this.left.mapKind == "message" ? this.left.message : undefined; + return this; + } + } + err(what) { + return new InvalidPathError(this.schema, "Invalid " + what, this.path); + } +} +function checkKeyType(key, type) { + switch (type) { + case descriptors_js_1.ScalarType.STRING: + return typeof key == "string"; + case descriptors_js_1.ScalarType.INT32: + case descriptors_js_1.ScalarType.UINT32: + case descriptors_js_1.ScalarType.SINT32: + case descriptors_js_1.ScalarType.SFIXED32: + case descriptors_js_1.ScalarType.FIXED32: + return typeof key == "number"; + case descriptors_js_1.ScalarType.UINT64: + case descriptors_js_1.ScalarType.INT64: + case descriptors_js_1.ScalarType.FIXED64: + case descriptors_js_1.ScalarType.SFIXED64: + case descriptors_js_1.ScalarType.SINT64: + return typeof key == "bigint"; + case descriptors_js_1.ScalarType.BOOL: + return typeof key == "boolean"; + } +} +function nextToken(i, path) { + const re_extension = /^[A-Za-z_][A-Za-z_0-9]*(?:\.[A-Za-z_][A-Za-z_0-9]*)*$/; + const re_field = /^[A-Za-z_][A-Za-z_0-9]*$/; + if (path[i] == "[") { + i++; + while (path[i] == " ") { + // skip leading whitespace + i++; + } + if (i >= path.length) { + return { err: "Premature end", i: path.length - 1 }; + } + let token; + if (path[i] == `"`) { + // string literal + i++; + let val = ""; + for (;;) { + if (path[i] == `"`) { + // end of string literal + i++; + break; + } + if (path[i] == "\\") { + switch (path[i + 1]) { + case `"`: + case "\\": + val += path[i + 1]; + break; + case "r": + val += "\r"; + break; + case "n": + val += "\n"; + break; + default: + return { err: "Invalid escape sequence", i }; + } + i++; + } + else { + val += path[i]; + } + if (i >= path.length) { + return { err: "Premature end of string", i: path.length - 1 }; + } + i++; + } + token = { val }; + } + else if (path[i].match(/\d/)) { + // integer literal + const start = i; + while (i < path.length && /\d/.test(path[i])) { + i++; + } + token = { val: BigInt(path.substring(start, i)) }; + } + else if (path[i] == "]") { + return { err: "Premature ]", i }; + } + else { + // extension identifier or bool literal + const start = i; + while (i < path.length && path[i] != " " && path[i] != "]") { + i++; + } + const name = path.substring(start, i); + if (name === "true") { + token = { val: true }; + } + else if (name === "false") { + token = { val: false }; + } + else if (re_extension.test(name)) { + token = { ext: name }; + } + else { + return { err: "Invalid ident", i: start }; + } + } + while (path[i] == " ") { + // skip trailing whitespace + i++; + } + if (path[i] != "]") { + return { err: "Missing ]", i }; + } + i++; + return Object.assign(Object.assign({}, token), { i }); + } + // field identifier + if (i > 0) { + if (path[i] != ".") { + return { err: `Expected "."`, i }; + } + i++; + } + const start = i; + while (i < path.length && path[i] != "." && path[i] != "[") { + i++; + } + const field = path.substring(start, i); + return re_field.test(field) + ? { field, i } + : { err: "Invalid ident", i: start }; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-check.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-check.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..63f27b9e9befaa9d9e0e67d2aaeefde0843f2173 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-check.d.ts @@ -0,0 +1,19 @@ +import { type DescField } from "../descriptors.js"; +import { FieldError } from "./error.js"; +/** + * Check whether the given field value is valid for the reflect API. + */ +export declare function checkField(field: DescField, value: unknown): FieldError | undefined; +/** + * Check whether the given list item is valid for the reflect API. + */ +export declare function checkListItem(field: DescField & { + fieldKind: "list"; +}, index: number, value: unknown): FieldError | undefined; +/** + * Check whether the given map key and value are valid for the reflect API. + */ +export declare function checkMapEntry(field: DescField & { + fieldKind: "map"; +}, key: unknown, value: unknown): FieldError | undefined; +export declare function formatVal(val: unknown): string; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-check.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-check.js new file mode 100644 index 0000000000000000000000000000000000000000..caa755759691c478e82714370172d8c1123e58a2 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-check.js @@ -0,0 +1,266 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.checkField = checkField; +exports.checkListItem = checkListItem; +exports.checkMapEntry = checkMapEntry; +exports.formatVal = formatVal; +const descriptors_js_1 = require("../descriptors.js"); +const is_message_js_1 = require("../is-message.js"); +const error_js_1 = require("./error.js"); +const guard_js_1 = require("./guard.js"); +const binary_encoding_js_1 = require("../wire/binary-encoding.js"); +const text_encoding_js_1 = require("../wire/text-encoding.js"); +const proto_int64_js_1 = require("../proto-int64.js"); +/** + * Check whether the given field value is valid for the reflect API. + */ +function checkField(field, value) { + const check = field.fieldKind == "list" + ? (0, guard_js_1.isReflectList)(value, field) + : field.fieldKind == "map" + ? (0, guard_js_1.isReflectMap)(value, field) + : checkSingular(field, value); + if (check === true) { + return undefined; + } + let reason; + switch (field.fieldKind) { + case "list": + reason = `expected ${formatReflectList(field)}, got ${formatVal(value)}`; + break; + case "map": + reason = `expected ${formatReflectMap(field)}, got ${formatVal(value)}`; + break; + default: { + reason = reasonSingular(field, value, check); + } + } + return new error_js_1.FieldError(field, reason); +} +/** + * Check whether the given list item is valid for the reflect API. + */ +function checkListItem(field, index, value) { + const check = checkSingular(field, value); + if (check !== true) { + return new error_js_1.FieldError(field, `list item #${index + 1}: ${reasonSingular(field, value, check)}`); + } + return undefined; +} +/** + * Check whether the given map key and value are valid for the reflect API. + */ +function checkMapEntry(field, key, value) { + const checkKey = checkScalarValue(key, field.mapKey); + if (checkKey !== true) { + return new error_js_1.FieldError(field, `invalid map key: ${reasonSingular({ scalar: field.mapKey }, key, checkKey)}`); + } + const checkVal = checkSingular(field, value); + if (checkVal !== true) { + return new error_js_1.FieldError(field, `map entry ${formatVal(key)}: ${reasonSingular(field, value, checkVal)}`); + } + return undefined; +} +function checkSingular(field, value) { + if (field.scalar !== undefined) { + return checkScalarValue(value, field.scalar); + } + if (field.enum !== undefined) { + if (field.enum.open) { + return Number.isInteger(value); + } + return field.enum.values.some((v) => v.number === value); + } + return (0, guard_js_1.isReflectMessage)(value, field.message); +} +function checkScalarValue(value, scalar) { + switch (scalar) { + case descriptors_js_1.ScalarType.DOUBLE: + return typeof value == "number"; + case descriptors_js_1.ScalarType.FLOAT: + if (typeof value != "number") { + return false; + } + if (Number.isNaN(value) || !Number.isFinite(value)) { + return true; + } + if (value > binary_encoding_js_1.FLOAT32_MAX || value < binary_encoding_js_1.FLOAT32_MIN) { + return `${value.toFixed()} out of range`; + } + return true; + case descriptors_js_1.ScalarType.INT32: + case descriptors_js_1.ScalarType.SFIXED32: + case descriptors_js_1.ScalarType.SINT32: + // signed + if (typeof value !== "number" || !Number.isInteger(value)) { + return false; + } + if (value > binary_encoding_js_1.INT32_MAX || value < binary_encoding_js_1.INT32_MIN) { + return `${value.toFixed()} out of range`; + } + return true; + case descriptors_js_1.ScalarType.FIXED32: + case descriptors_js_1.ScalarType.UINT32: + // unsigned + if (typeof value !== "number" || !Number.isInteger(value)) { + return false; + } + if (value > binary_encoding_js_1.UINT32_MAX || value < 0) { + return `${value.toFixed()} out of range`; + } + return true; + case descriptors_js_1.ScalarType.BOOL: + return typeof value == "boolean"; + case descriptors_js_1.ScalarType.STRING: + if (typeof value != "string") { + return false; + } + return (0, text_encoding_js_1.getTextEncoding)().checkUtf8(value) || "invalid UTF8"; + case descriptors_js_1.ScalarType.BYTES: + return value instanceof Uint8Array; + case descriptors_js_1.ScalarType.INT64: + case descriptors_js_1.ScalarType.SFIXED64: + case descriptors_js_1.ScalarType.SINT64: + // signed + if (typeof value == "bigint" || + typeof value == "number" || + (typeof value == "string" && value.length > 0)) { + try { + proto_int64_js_1.protoInt64.parse(value); + return true; + } + catch (_) { + return `${value} out of range`; + } + } + return false; + case descriptors_js_1.ScalarType.FIXED64: + case descriptors_js_1.ScalarType.UINT64: + // unsigned + if (typeof value == "bigint" || + typeof value == "number" || + (typeof value == "string" && value.length > 0)) { + try { + proto_int64_js_1.protoInt64.uParse(value); + return true; + } + catch (_) { + return `${value} out of range`; + } + } + return false; + } +} +function reasonSingular(field, val, details) { + details = + typeof details == "string" ? `: ${details}` : `, got ${formatVal(val)}`; + if (field.scalar !== undefined) { + return `expected ${scalarTypeDescription(field.scalar)}` + details; + } + if (field.enum !== undefined) { + return `expected ${field.enum.toString()}` + details; + } + return `expected ${formatReflectMessage(field.message)}` + details; +} +function formatVal(val) { + switch (typeof val) { + case "object": + if (val === null) { + return "null"; + } + if (val instanceof Uint8Array) { + return `Uint8Array(${val.length})`; + } + if (Array.isArray(val)) { + return `Array(${val.length})`; + } + if ((0, guard_js_1.isReflectList)(val)) { + return formatReflectList(val.field()); + } + if ((0, guard_js_1.isReflectMap)(val)) { + return formatReflectMap(val.field()); + } + if ((0, guard_js_1.isReflectMessage)(val)) { + return formatReflectMessage(val.desc); + } + if ((0, is_message_js_1.isMessage)(val)) { + return `message ${val.$typeName}`; + } + return "object"; + case "string": + return val.length > 30 ? "string" : `"${val.split('"').join('\\"')}"`; + case "boolean": + return String(val); + case "number": + return String(val); + case "bigint": + return String(val) + "n"; + default: + // "symbol" | "undefined" | "object" | "function" + return typeof val; + } +} +function formatReflectMessage(desc) { + return `ReflectMessage (${desc.typeName})`; +} +function formatReflectList(field) { + switch (field.listKind) { + case "message": + return `ReflectList (${field.message.toString()})`; + case "enum": + return `ReflectList (${field.enum.toString()})`; + case "scalar": + return `ReflectList (${descriptors_js_1.ScalarType[field.scalar]})`; + } +} +function formatReflectMap(field) { + switch (field.mapKind) { + case "message": + return `ReflectMap (${descriptors_js_1.ScalarType[field.mapKey]}, ${field.message.toString()})`; + case "enum": + return `ReflectMap (${descriptors_js_1.ScalarType[field.mapKey]}, ${field.enum.toString()})`; + case "scalar": + return `ReflectMap (${descriptors_js_1.ScalarType[field.mapKey]}, ${descriptors_js_1.ScalarType[field.scalar]})`; + } +} +function scalarTypeDescription(scalar) { + switch (scalar) { + case descriptors_js_1.ScalarType.STRING: + return "string"; + case descriptors_js_1.ScalarType.BOOL: + return "boolean"; + case descriptors_js_1.ScalarType.INT64: + case descriptors_js_1.ScalarType.SINT64: + case descriptors_js_1.ScalarType.SFIXED64: + return "bigint (int64)"; + case descriptors_js_1.ScalarType.UINT64: + case descriptors_js_1.ScalarType.FIXED64: + return "bigint (uint64)"; + case descriptors_js_1.ScalarType.BYTES: + return "Uint8Array"; + case descriptors_js_1.ScalarType.DOUBLE: + return "number (float64)"; + case descriptors_js_1.ScalarType.FLOAT: + return "number (float32)"; + case descriptors_js_1.ScalarType.FIXED32: + case descriptors_js_1.ScalarType.UINT32: + return "number (uint32)"; + case descriptors_js_1.ScalarType.INT32: + case descriptors_js_1.ScalarType.SFIXED32: + case descriptors_js_1.ScalarType.SINT32: + return "number (int32)"; + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-types.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-types.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f300dd9e2d48f6928ec786f5eaa24d31c011a37b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-types.d.ts @@ -0,0 +1,217 @@ +import type { DescField, DescMessage, DescOneof } from "../descriptors.js"; +import { unsafeLocal } from "./unsafe.js"; +import type { Message, UnknownField } from "../types.js"; +import type { ScalarValue } from "./scalar.js"; +/** + * ReflectMessage provides dynamic access and manipulation of a message. + */ +export interface ReflectMessage { + /** + * The underlying message instance. + */ + readonly message: Message; + /** + * The descriptor for the message. + */ + readonly desc: DescMessage; + /** + * The fields of the message. This is a shortcut to message.fields. + */ + readonly fields: readonly DescField[]; + /** + * The fields of the message, sorted by field number ascending. + */ + readonly sortedFields: readonly DescField[]; + /** + * Oneof groups of the message. This is a shortcut to message.oneofs. + */ + readonly oneofs: readonly DescOneof[]; + /** + * Fields and oneof groups for this message. This is a shortcut to message.members. + */ + readonly members: readonly (DescField | DescOneof)[]; + /** + * Find a field by number. + */ + findNumber(number: number): DescField | undefined; + /** + * Returns true if the field is set. + * + * - Scalar and enum fields with implicit presence (proto3): + * Set if not a zero value. + * + * - Scalar and enum fields with explicit presence (proto2, oneof): + * Set if a value was set when creating or parsing the message, or when a + * value was assigned to the field's property. + * + * - Message fields: + * Set if the property is not undefined. + * + * - List and map fields: + * Set if not empty. + */ + isSet(field: DescField): boolean; + /** + * Resets the field, so that isSet() will return false. + */ + clear(field: DescField): void; + /** + * Return the selected field of a oneof group. + */ + oneofCase(oneof: DescOneof): DescField | undefined; + /** + * Returns the field value. Values are converted or wrapped to make it easier + * to manipulate messages. + * + * - Scalar fields: + * Returns the value, but converts 64-bit integer fields with the option + * `jstype=JS_STRING` to a bigint value. + * If the field is not set, the default value is returned. If no default + * value is set, the zero value is returned. + * + * - Enum fields: + * Returns the numeric value. If the field is not set, the default value is + * returned. If no default value is set, the zero value is returned. + * + * - Message fields: + * Returns a ReflectMessage. If the field is not set, a new message is + * returned, but not set on the field. + * + * - List fields: + * Returns a ReflectList object. + * + * - Map fields: + * Returns a ReflectMap object. + * + * Note that get() never returns `undefined`. To determine whether a field is + * set, use isSet(). + */ + get(field: Field): ReflectMessageGet; + /** + * Set a field value. + * + * Expects values in the same form that get() returns: + * + * - Scalar fields: + * 64-bit integer fields with the option `jstype=JS_STRING` as a bigint value. + * + * - Message fields: + * ReflectMessage. + * + * - List fields: + * ReflectList. + * + * - Map fields: + * ReflectMap. + * + * Throws an error if the value is invalid for the field. `undefined` is not + * a valid value. To reset a field, use clear(). + */ + set(field: Field, value: unknown): void; + /** + * Returns the unknown fields of the message. + */ + getUnknown(): UnknownField[] | undefined; + /** + * Sets the unknown fields of the message, overwriting any previous values. + */ + setUnknown(value: UnknownField[]): void; + [unsafeLocal]: Message; +} +/** + * ReflectList provides dynamic access and manipulation of a list field on a + * message. + * + * ReflectList is iterable - you can loop through all items with a for...of loop. + * + * Values are converted or wrapped to make it easier to manipulate them: + * - Scalar 64-bit integer fields with the option `jstype=JS_STRING` are + * converted to bigint. + * - Messages are wrapped in a ReflectMessage. + */ +export interface ReflectList extends Iterable { + /** + * Returns the list field. + */ + field(): DescField & { + fieldKind: "list"; + }; + /** + * The size of the list. + */ + readonly size: number; + /** + * Retrieves the item at the specified index, or undefined if the index + * is out of range. + */ + get(index: number): V | undefined; + /** + * Adds an item at the end of the list. + * Throws an error if an item is invalid for this list. + */ + add(item: V): void; + /** + * Replaces the item at the specified index with the specified item. + * Throws an error if the index is out of range (index < 0 || index >= size). + * Throws an error if the item is invalid for this list. + */ + set(index: number, item: V): void; + /** + * Removes all items from the list. + */ + clear(): void; + [Symbol.iterator](): IterableIterator; + entries(): IterableIterator<[number, V]>; + keys(): IterableIterator; + values(): IterableIterator; + [unsafeLocal]: unknown[]; +} +/** + * ReflectMap provides dynamic access and manipulation of a map field on a + * message. + * + * ReflectMap is iterable - you can loop through all entries with a for...of loop. + * + * Keys and values are converted or wrapped to make it easier to manipulate them: + * - A map field is a record object on a message, where keys are always strings. + * ReflectMap converts keys to their closest possible type in TypeScript. + * - Messages are wrapped in a ReflectMessage. + */ +export interface ReflectMap extends ReadonlyMap { + /** + * Returns the map field. + */ + field(): DescField & { + fieldKind: "map"; + }; + /** + * Removes the entry for the specified key. + * Returns false if the key is unknown. + */ + delete(key: K): boolean; + /** + * Sets or replaces the item at the specified key with the specified value. + * Throws an error if the key or value is invalid for this map. + */ + set(key: K, value: V): this; + /** + * Removes all entries from the map. + */ + clear(): void; + [unsafeLocal]: Record; +} +/** + * The return type of ReflectMessage.get() + */ +export type ReflectMessageGet = (Field extends { + fieldKind: "map"; +} ? ReflectMap : Field extends { + fieldKind: "list"; +} ? ReflectList : Field extends { + fieldKind: "enum"; +} ? number : Field extends { + fieldKind: "message"; +} ? ReflectMessage : Field extends { + fieldKind: "scalar"; + scalar: infer T; +} ? ScalarValue : never); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-types.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-types.js new file mode 100644 index 0000000000000000000000000000000000000000..737751a75c1bc812b45d8e02fcd0e15f3394df85 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect-types.js @@ -0,0 +1,16 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +const unsafe_js_1 = require("./unsafe.js"); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3bfb1adbb2e7f2488cc3e5acbb54d9da48291f10 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect.d.ts @@ -0,0 +1,43 @@ +import { type DescField, type DescMessage } from "../descriptors.js"; +import type { MessageShape } from "../types.js"; +import type { ReflectList, ReflectMap, ReflectMessage } from "./reflect-types.js"; +/** + * Create a ReflectMessage. + */ +export declare function reflect(messageDesc: Desc, message?: MessageShape, +/** + * By default, field values are validated when setting them. For example, + * a value for an uint32 field must be a ECMAScript Number >= 0. + * + * When field values are trusted, performance can be improved by disabling + * checks. + */ +check?: boolean): ReflectMessage; +/** + * Create a ReflectList. + */ +export declare function reflectList(field: DescField & { + fieldKind: "list"; +}, unsafeInput?: unknown[], +/** + * By default, field values are validated when setting them. For example, + * a value for an uint32 field must be a ECMAScript Number >= 0. + * + * When field values are trusted, performance can be improved by disabling + * checks. + */ +check?: boolean): ReflectList; +/** + * Create a ReflectMap. + */ +export declare function reflectMap(field: DescField & { + fieldKind: "map"; +}, unsafeInput?: Record, +/** + * By default, field values are validated when setting them. For example, + * a value for an uint32 field must be a ECMAScript Number >= 0. + * + * When field values are trusted, performance can be improved by disabling + * checks. + */ +check?: boolean): ReflectMap; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect.js new file mode 100644 index 0000000000000000000000000000000000000000..91cc5caac5b568df41e8424a0e02e13e43167dec --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/reflect.js @@ -0,0 +1,541 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.reflect = reflect; +exports.reflectList = reflectList; +exports.reflectMap = reflectMap; +const descriptors_js_1 = require("../descriptors.js"); +const reflect_check_js_1 = require("./reflect-check.js"); +const error_js_1 = require("./error.js"); +const unsafe_js_1 = require("./unsafe.js"); +const create_js_1 = require("../create.js"); +const wrappers_js_1 = require("../wkt/wrappers.js"); +const scalar_js_1 = require("./scalar.js"); +const proto_int64_js_1 = require("../proto-int64.js"); +const guard_js_1 = require("./guard.js"); +/** + * Create a ReflectMessage. + */ +function reflect(messageDesc, message, +/** + * By default, field values are validated when setting them. For example, + * a value for an uint32 field must be a ECMAScript Number >= 0. + * + * When field values are trusted, performance can be improved by disabling + * checks. + */ +check = true) { + return new ReflectMessageImpl(messageDesc, message, check); +} +class ReflectMessageImpl { + get sortedFields() { + var _a; + return ((_a = this._sortedFields) !== null && _a !== void 0 ? _a : + // biome-ignore lint/suspicious/noAssignInExpressions: no + (this._sortedFields = this.desc.fields + .concat() + .sort((a, b) => a.number - b.number))); + } + constructor(messageDesc, message, check = true) { + this.lists = new Map(); + this.maps = new Map(); + this.check = check; + this.desc = messageDesc; + this.message = this[unsafe_js_1.unsafeLocal] = message !== null && message !== void 0 ? message : (0, create_js_1.create)(messageDesc); + this.fields = messageDesc.fields; + this.oneofs = messageDesc.oneofs; + this.members = messageDesc.members; + } + findNumber(number) { + if (!this._fieldsByNumber) { + this._fieldsByNumber = new Map(this.desc.fields.map((f) => [f.number, f])); + } + return this._fieldsByNumber.get(number); + } + oneofCase(oneof) { + assertOwn(this.message, oneof); + return (0, unsafe_js_1.unsafeOneofCase)(this.message, oneof); + } + isSet(field) { + assertOwn(this.message, field); + return (0, unsafe_js_1.unsafeIsSet)(this.message, field); + } + clear(field) { + assertOwn(this.message, field); + (0, unsafe_js_1.unsafeClear)(this.message, field); + } + get(field) { + assertOwn(this.message, field); + const value = (0, unsafe_js_1.unsafeGet)(this.message, field); + switch (field.fieldKind) { + case "list": + // eslint-disable-next-line no-case-declarations + let list = this.lists.get(field); + if (!list || list[unsafe_js_1.unsafeLocal] !== value) { + this.lists.set(field, + // biome-ignore lint/suspicious/noAssignInExpressions: no + (list = new ReflectListImpl(field, value, this.check))); + } + return list; + case "map": + let map = this.maps.get(field); + if (!map || map[unsafe_js_1.unsafeLocal] !== value) { + this.maps.set(field, + // biome-ignore lint/suspicious/noAssignInExpressions: no + (map = new ReflectMapImpl(field, value, this.check))); + } + return map; + case "message": + return messageToReflect(field, value, this.check); + case "scalar": + return (value === undefined + ? (0, scalar_js_1.scalarZeroValue)(field.scalar, false) + : longToReflect(field, value)); + case "enum": + return (value !== null && value !== void 0 ? value : field.enum.values[0].number); + } + } + set(field, value) { + assertOwn(this.message, field); + if (this.check) { + const err = (0, reflect_check_js_1.checkField)(field, value); + if (err) { + throw err; + } + } + let local; + if (field.fieldKind == "message") { + local = messageToLocal(field, value); + } + else if ((0, guard_js_1.isReflectMap)(value) || (0, guard_js_1.isReflectList)(value)) { + local = value[unsafe_js_1.unsafeLocal]; + } + else { + local = longToLocal(field, value); + } + (0, unsafe_js_1.unsafeSet)(this.message, field, local); + } + getUnknown() { + return this.message.$unknown; + } + setUnknown(value) { + this.message.$unknown = value; + } +} +function assertOwn(owner, member) { + if (member.parent.typeName !== owner.$typeName) { + throw new error_js_1.FieldError(member, `cannot use ${member.toString()} with message ${owner.$typeName}`, "ForeignFieldError"); + } +} +/** + * Create a ReflectList. + */ +function reflectList(field, unsafeInput, +/** + * By default, field values are validated when setting them. For example, + * a value for an uint32 field must be a ECMAScript Number >= 0. + * + * When field values are trusted, performance can be improved by disabling + * checks. + */ +check = true) { + return new ReflectListImpl(field, unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : [], check); +} +class ReflectListImpl { + field() { + return this._field; + } + get size() { + return this._arr.length; + } + constructor(field, unsafeInput, check) { + this._field = field; + this._arr = this[unsafe_js_1.unsafeLocal] = unsafeInput; + this.check = check; + } + get(index) { + const item = this._arr[index]; + return item === undefined + ? undefined + : listItemToReflect(this._field, item, this.check); + } + set(index, item) { + if (index < 0 || index >= this._arr.length) { + throw new error_js_1.FieldError(this._field, `list item #${index + 1}: out of range`); + } + if (this.check) { + const err = (0, reflect_check_js_1.checkListItem)(this._field, index, item); + if (err) { + throw err; + } + } + this._arr[index] = listItemToLocal(this._field, item); + } + add(item) { + if (this.check) { + const err = (0, reflect_check_js_1.checkListItem)(this._field, this._arr.length, item); + if (err) { + throw err; + } + } + this._arr.push(listItemToLocal(this._field, item)); + return undefined; + } + clear() { + this._arr.splice(0, this._arr.length); + } + [Symbol.iterator]() { + return this.values(); + } + keys() { + return this._arr.keys(); + } + *values() { + for (const item of this._arr) { + yield listItemToReflect(this._field, item, this.check); + } + } + *entries() { + for (let i = 0; i < this._arr.length; i++) { + yield [i, listItemToReflect(this._field, this._arr[i], this.check)]; + } + } +} +/** + * Create a ReflectMap. + */ +function reflectMap(field, unsafeInput, +/** + * By default, field values are validated when setting them. For example, + * a value for an uint32 field must be a ECMAScript Number >= 0. + * + * When field values are trusted, performance can be improved by disabling + * checks. + */ +check = true) { + return new ReflectMapImpl(field, unsafeInput, check); +} +class ReflectMapImpl { + constructor(field, unsafeInput, check = true) { + this.obj = this[unsafe_js_1.unsafeLocal] = unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : {}; + this.check = check; + this._field = field; + } + field() { + return this._field; + } + set(key, value) { + if (this.check) { + const err = (0, reflect_check_js_1.checkMapEntry)(this._field, key, value); + if (err) { + throw err; + } + } + this.obj[mapKeyToLocal(key)] = mapValueToLocal(this._field, value); + return this; + } + delete(key) { + const k = mapKeyToLocal(key); + const has = Object.prototype.hasOwnProperty.call(this.obj, k); + if (has) { + delete this.obj[k]; + } + return has; + } + clear() { + for (const key of Object.keys(this.obj)) { + delete this.obj[key]; + } + } + get(key) { + let val = this.obj[mapKeyToLocal(key)]; + if (val !== undefined) { + val = mapValueToReflect(this._field, val, this.check); + } + return val; + } + has(key) { + return Object.prototype.hasOwnProperty.call(this.obj, mapKeyToLocal(key)); + } + *keys() { + for (const objKey of Object.keys(this.obj)) { + yield mapKeyToReflect(objKey, this._field.mapKey); + } + } + *entries() { + for (const objEntry of Object.entries(this.obj)) { + yield [ + mapKeyToReflect(objEntry[0], this._field.mapKey), + mapValueToReflect(this._field, objEntry[1], this.check), + ]; + } + } + [Symbol.iterator]() { + return this.entries(); + } + get size() { + return Object.keys(this.obj).length; + } + *values() { + for (const val of Object.values(this.obj)) { + yield mapValueToReflect(this._field, val, this.check); + } + } + forEach(callbackfn, thisArg) { + for (const mapEntry of this.entries()) { + callbackfn.call(thisArg, mapEntry[1], mapEntry[0], this); + } + } +} +function messageToLocal(field, value) { + if (!(0, guard_js_1.isReflectMessage)(value)) { + return value; + } + if ((0, wrappers_js_1.isWrapper)(value.message) && + !field.oneof && + field.fieldKind == "message") { + // Types from google/protobuf/wrappers.proto are unwrapped when used in + // a singular field that is not part of a oneof group. + return value.message.value; + } + if (value.desc.typeName == "google.protobuf.Struct" && + field.parent.typeName != "google.protobuf.Value") { + // google.protobuf.Struct is represented with JsonObject when used in a + // field, except when used in google.protobuf.Value. + return wktStructToLocal(value.message); + } + return value.message; +} +function messageToReflect(field, value, check) { + if (value !== undefined) { + if ((0, wrappers_js_1.isWrapperDesc)(field.message) && + !field.oneof && + field.fieldKind == "message") { + // Types from google/protobuf/wrappers.proto are unwrapped when used in + // a singular field that is not part of a oneof group. + value = { + $typeName: field.message.typeName, + value: longToReflect(field.message.fields[0], value), + }; + } + else if (field.message.typeName == "google.protobuf.Struct" && + field.parent.typeName != "google.protobuf.Value" && + (0, guard_js_1.isObject)(value)) { + // google.protobuf.Struct is represented with JsonObject when used in a + // field, except when used in google.protobuf.Value. + value = wktStructToReflect(value); + } + } + return new ReflectMessageImpl(field.message, value, check); +} +function listItemToLocal(field, value) { + if (field.listKind == "message") { + return messageToLocal(field, value); + } + return longToLocal(field, value); +} +function listItemToReflect(field, value, check) { + if (field.listKind == "message") { + return messageToReflect(field, value, check); + } + return longToReflect(field, value); +} +function mapValueToLocal(field, value) { + if (field.mapKind == "message") { + return messageToLocal(field, value); + } + return longToLocal(field, value); +} +function mapValueToReflect(field, value, check) { + if (field.mapKind == "message") { + return messageToReflect(field, value, check); + } + return value; +} +function mapKeyToLocal(key) { + return typeof key == "string" || typeof key == "number" ? key : String(key); +} +/** + * Converts a map key (any scalar value except float, double, or bytes) from its + * representation in a message (string or number, the only possible object key + * types) to the closest possible type in ECMAScript. + */ +function mapKeyToReflect(key, type) { + switch (type) { + case descriptors_js_1.ScalarType.STRING: + return key; + case descriptors_js_1.ScalarType.INT32: + case descriptors_js_1.ScalarType.FIXED32: + case descriptors_js_1.ScalarType.UINT32: + case descriptors_js_1.ScalarType.SFIXED32: + case descriptors_js_1.ScalarType.SINT32: { + const n = Number.parseInt(key); + if (Number.isFinite(n)) { + return n; + } + break; + } + case descriptors_js_1.ScalarType.BOOL: + switch (key) { + case "true": + return true; + case "false": + return false; + } + break; + case descriptors_js_1.ScalarType.UINT64: + case descriptors_js_1.ScalarType.FIXED64: + try { + return proto_int64_js_1.protoInt64.uParse(key); + } + catch (_a) { + // + } + break; + default: + // INT64, SFIXED64, SINT64 + try { + return proto_int64_js_1.protoInt64.parse(key); + } + catch (_b) { + // + } + break; + } + return key; +} +function longToReflect(field, value) { + switch (field.scalar) { + case descriptors_js_1.ScalarType.INT64: + case descriptors_js_1.ScalarType.SFIXED64: + case descriptors_js_1.ScalarType.SINT64: + if ("longAsString" in field && + field.longAsString && + typeof value == "string") { + value = proto_int64_js_1.protoInt64.parse(value); + } + break; + case descriptors_js_1.ScalarType.FIXED64: + case descriptors_js_1.ScalarType.UINT64: + if ("longAsString" in field && + field.longAsString && + typeof value == "string") { + value = proto_int64_js_1.protoInt64.uParse(value); + } + break; + } + return value; +} +function longToLocal(field, value) { + switch (field.scalar) { + case descriptors_js_1.ScalarType.INT64: + case descriptors_js_1.ScalarType.SFIXED64: + case descriptors_js_1.ScalarType.SINT64: + if ("longAsString" in field && field.longAsString) { + value = String(value); + } + else if (typeof value == "string" || typeof value == "number") { + value = proto_int64_js_1.protoInt64.parse(value); + } + break; + case descriptors_js_1.ScalarType.FIXED64: + case descriptors_js_1.ScalarType.UINT64: + if ("longAsString" in field && field.longAsString) { + value = String(value); + } + else if (typeof value == "string" || typeof value == "number") { + value = proto_int64_js_1.protoInt64.uParse(value); + } + break; + } + return value; +} +function wktStructToReflect(json) { + const struct = { + $typeName: "google.protobuf.Struct", + fields: {}, + }; + if ((0, guard_js_1.isObject)(json)) { + for (const [k, v] of Object.entries(json)) { + struct.fields[k] = wktValueToReflect(v); + } + } + return struct; +} +function wktStructToLocal(val) { + const json = {}; + for (const [k, v] of Object.entries(val.fields)) { + json[k] = wktValueToLocal(v); + } + return json; +} +function wktValueToLocal(val) { + switch (val.kind.case) { + case "structValue": + return wktStructToLocal(val.kind.value); + case "listValue": + return val.kind.value.values.map(wktValueToLocal); + case "nullValue": + case undefined: + return null; + default: + return val.kind.value; + } +} +function wktValueToReflect(json) { + const value = { + $typeName: "google.protobuf.Value", + kind: { case: undefined }, + }; + switch (typeof json) { + case "number": + value.kind = { case: "numberValue", value: json }; + break; + case "string": + value.kind = { case: "stringValue", value: json }; + break; + case "boolean": + value.kind = { case: "boolValue", value: json }; + break; + case "object": + if (json === null) { + const nullValue = 0; + value.kind = { case: "nullValue", value: nullValue }; + } + else if (Array.isArray(json)) { + const listValue = { + $typeName: "google.protobuf.ListValue", + values: [], + }; + if (Array.isArray(json)) { + for (const e of json) { + listValue.values.push(wktValueToReflect(e)); + } + } + value.kind = { + case: "listValue", + value: listValue, + }; + } + else { + value.kind = { + case: "structValue", + value: wktStructToReflect(json), + }; + } + break; + } + return value; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/scalar.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/scalar.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..16ac91fe34d86972ada05033b9728b60a724df17 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/scalar.d.ts @@ -0,0 +1,21 @@ +import { ScalarType } from "../descriptors.js"; +/** + * ScalarValue maps from a scalar field type to a TypeScript value type. + */ +export type ScalarValue = T extends ScalarType.STRING ? string : T extends ScalarType.INT32 ? number : T extends ScalarType.UINT32 ? number : T extends ScalarType.SINT32 ? number : T extends ScalarType.FIXED32 ? number : T extends ScalarType.SFIXED32 ? number : T extends ScalarType.FLOAT ? number : T extends ScalarType.DOUBLE ? number : T extends ScalarType.INT64 ? LongAsString extends true ? string : bigint : T extends ScalarType.SINT64 ? LongAsString extends true ? string : bigint : T extends ScalarType.SFIXED64 ? LongAsString extends true ? string : bigint : T extends ScalarType.UINT64 ? LongAsString extends true ? string : bigint : T extends ScalarType.FIXED64 ? LongAsString extends true ? string : bigint : T extends ScalarType.BOOL ? boolean : T extends ScalarType.BYTES ? Uint8Array : never; +/** + * Returns true if both scalar values are equal. + */ +export declare function scalarEquals(type: ScalarType, a: ScalarValue | undefined, b: ScalarValue | undefined): boolean; +/** + * Returns the zero value for the given scalar type. + */ +export declare function scalarZeroValue(type: T, longAsString: LongAsString): ScalarValue; +/** + * Returns true for a zero-value. For example, an integer has the zero-value `0`, + * a boolean is `false`, a string is `""`, and bytes is an empty Uint8Array. + * + * In proto3, zero-values are not written to the wire, unless the field is + * optional or repeated. + */ +export declare function isScalarZeroValue(type: ScalarType, value: unknown): boolean; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/scalar.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/scalar.js new file mode 100644 index 0000000000000000000000000000000000000000..f4e6c4a9e1f138901ce462e450756c6019741efe --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/scalar.js @@ -0,0 +1,102 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.scalarEquals = scalarEquals; +exports.scalarZeroValue = scalarZeroValue; +exports.isScalarZeroValue = isScalarZeroValue; +const proto_int64_js_1 = require("../proto-int64.js"); +const descriptors_js_1 = require("../descriptors.js"); +/** + * Returns true if both scalar values are equal. + */ +function scalarEquals(type, a, b) { + if (a === b) { + // This correctly matches equal values except BYTES and (possibly) 64-bit integers. + return true; + } + // Special case BYTES - we need to compare each byte individually + if (type == descriptors_js_1.ScalarType.BYTES) { + if (!(a instanceof Uint8Array) || !(b instanceof Uint8Array)) { + return false; + } + if (a.length !== b.length) { + return false; + } + for (let i = 0; i < a.length; i++) { + if (a[i] !== b[i]) { + return false; + } + } + return true; + } + // Special case 64-bit integers - we support number, string and bigint representation. + switch (type) { + case descriptors_js_1.ScalarType.UINT64: + case descriptors_js_1.ScalarType.FIXED64: + case descriptors_js_1.ScalarType.INT64: + case descriptors_js_1.ScalarType.SFIXED64: + case descriptors_js_1.ScalarType.SINT64: + // Loose comparison will match between 0n, 0 and "0". + return a == b; + } + // Anything that hasn't been caught by strict comparison or special cased + // BYTES and 64-bit integers is not equal. + return false; +} +/** + * Returns the zero value for the given scalar type. + */ +function scalarZeroValue(type, longAsString) { + switch (type) { + case descriptors_js_1.ScalarType.STRING: + return ""; + case descriptors_js_1.ScalarType.BOOL: + return false; + case descriptors_js_1.ScalarType.DOUBLE: + case descriptors_js_1.ScalarType.FLOAT: + return 0.0; + case descriptors_js_1.ScalarType.INT64: + case descriptors_js_1.ScalarType.UINT64: + case descriptors_js_1.ScalarType.SFIXED64: + case descriptors_js_1.ScalarType.FIXED64: + case descriptors_js_1.ScalarType.SINT64: + return (longAsString ? "0" : proto_int64_js_1.protoInt64.zero); + case descriptors_js_1.ScalarType.BYTES: + return new Uint8Array(0); + default: + // Handles INT32, UINT32, SINT32, FIXED32, SFIXED32. + // We do not use individual cases to save a few bytes code size. + return 0; + } +} +/** + * Returns true for a zero-value. For example, an integer has the zero-value `0`, + * a boolean is `false`, a string is `""`, and bytes is an empty Uint8Array. + * + * In proto3, zero-values are not written to the wire, unless the field is + * optional or repeated. + */ +function isScalarZeroValue(type, value) { + switch (type) { + case descriptors_js_1.ScalarType.BOOL: + return value === false; + case descriptors_js_1.ScalarType.STRING: + return value === ""; + case descriptors_js_1.ScalarType.BYTES: + return value instanceof Uint8Array && !value.byteLength; + default: + return value == 0; // Loose comparison matches 0n, 0 and "0" + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/unsafe.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/unsafe.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..02fd72f4a4cccde6a4c0711cdaf2ddc1ec72a063 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/unsafe.d.ts @@ -0,0 +1,39 @@ +import type { DescField, DescOneof } from "../descriptors.js"; +export declare const unsafeLocal: unique symbol; +/** + * Return the selected field of a oneof group. + * + * @private + */ +export declare function unsafeOneofCase(target: Record, oneof: DescOneof): DescField | undefined; +/** + * Returns true if the field is set. + * + * @private + */ +export declare function unsafeIsSet(target: Record, field: DescField): boolean; +/** + * Returns true if the field is set, but only for singular fields with explicit + * presence (proto2). + * + * @private + */ +export declare function unsafeIsSetExplicit(target: object, localName: string): boolean; +/** + * Return a field value, respecting oneof groups. + * + * @private + */ +export declare function unsafeGet(target: Record, field: DescField): unknown; +/** + * Set a field value, respecting oneof groups. + * + * @private + */ +export declare function unsafeSet(target: Record, field: DescField, value: unknown): void; +/** + * Resets the field, so that unsafeIsSet() will return false. + * + * @private + */ +export declare function unsafeClear(target: Record, field: DescField): void; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/unsafe.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/unsafe.js new file mode 100644 index 0000000000000000000000000000000000000000..33b6d4482ed548163aace8fd5c8d451844320fe6 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/reflect/unsafe.js @@ -0,0 +1,149 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.unsafeLocal = void 0; +exports.unsafeOneofCase = unsafeOneofCase; +exports.unsafeIsSet = unsafeIsSet; +exports.unsafeIsSetExplicit = unsafeIsSetExplicit; +exports.unsafeGet = unsafeGet; +exports.unsafeSet = unsafeSet; +exports.unsafeClear = unsafeClear; +const scalar_js_1 = require("./scalar.js"); +// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number; +const IMPLICIT = 2; +exports.unsafeLocal = Symbol.for("reflect unsafe local"); +/** + * Return the selected field of a oneof group. + * + * @private + */ +function unsafeOneofCase( +// biome-ignore lint/suspicious/noExplicitAny: `any` is the best choice for dynamic access +target, oneof) { + const c = target[oneof.localName].case; + if (c === undefined) { + return c; + } + return oneof.fields.find((f) => f.localName === c); +} +/** + * Returns true if the field is set. + * + * @private + */ +function unsafeIsSet( +// biome-ignore lint/suspicious/noExplicitAny: `any` is the best choice for dynamic access +target, field) { + const name = field.localName; + if (field.oneof) { + return target[field.oneof.localName].case === name; + } + if (field.presence != IMPLICIT) { + // Fields with explicit presence have properties on the prototype chain + // for default / zero values (except for proto3). + return (target[name] !== undefined && + Object.prototype.hasOwnProperty.call(target, name)); + } + switch (field.fieldKind) { + case "list": + return target[name].length > 0; + case "map": + return Object.keys(target[name]).length > 0; + case "scalar": + return !(0, scalar_js_1.isScalarZeroValue)(field.scalar, target[name]); + case "enum": + return target[name] !== field.enum.values[0].number; + } + throw new Error("message field with implicit presence"); +} +/** + * Returns true if the field is set, but only for singular fields with explicit + * presence (proto2). + * + * @private + */ +function unsafeIsSetExplicit(target, localName) { + return (Object.prototype.hasOwnProperty.call(target, localName) && + target[localName] !== undefined); +} +/** + * Return a field value, respecting oneof groups. + * + * @private + */ +function unsafeGet(target, field) { + if (field.oneof) { + const oneof = target[field.oneof.localName]; + if (oneof.case === field.localName) { + return oneof.value; + } + return undefined; + } + return target[field.localName]; +} +/** + * Set a field value, respecting oneof groups. + * + * @private + */ +function unsafeSet(target, field, value) { + if (field.oneof) { + target[field.oneof.localName] = { + case: field.localName, + value: value, + }; + } + else { + target[field.localName] = value; + } +} +/** + * Resets the field, so that unsafeIsSet() will return false. + * + * @private + */ +function unsafeClear( +// biome-ignore lint/suspicious/noExplicitAny: `any` is the best choice for dynamic access +target, field) { + const name = field.localName; + if (field.oneof) { + const oneofLocalName = field.oneof.localName; + if (target[oneofLocalName].case === name) { + target[oneofLocalName] = { case: undefined }; + } + } + else if (field.presence != IMPLICIT) { + // Fields with explicit presence have properties on the prototype chain + // for default / zero values (except for proto3). By deleting their own + // property, the field is reset. + delete target[name]; + } + else { + switch (field.fieldKind) { + case "map": + target[name] = {}; + break; + case "list": + target[name] = []; + break; + case "enum": + target[name] = field.enum.values[0].number; + break; + case "scalar": + target[name] = (0, scalar_js_1.scalarZeroValue)(field.scalar, field.longAsString); + break; + } + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/registry.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/registry.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4a1b5aedf1a5a8f626707a877a7d0008dce7f48a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/registry.d.ts @@ -0,0 +1,98 @@ +import type { FileDescriptorProto, FileDescriptorSet } from "./wkt/gen/google/protobuf/descriptor_pb.js"; +import { type DescEnum, type DescExtension, type DescFile, type DescMessage, type DescService, type SupportedEdition } from "./descriptors.js"; +/** + * A set of descriptors for messages, enumerations, extensions, + * and services. + */ +export interface Registry { + readonly kind: "registry"; + /** + * All types (message, enumeration, extension, or service) contained + * in this registry. + */ + [Symbol.iterator](): IterableIterator; + /** + * Look up a type (message, enumeration, extension, or service) by + * its fully qualified name. + */ + get(typeName: string): DescMessage | DescEnum | DescExtension | DescService | undefined; + /** + * Look up a message descriptor by its fully qualified name. + */ + getMessage(typeName: string): DescMessage | undefined; + /** + * Look up an enumeration descriptor by its fully qualified name. + */ + getEnum(typeName: string): DescEnum | undefined; + /** + * Look up an extension descriptor by its fully qualified name. + */ + getExtension(typeName: string): DescExtension | undefined; + /** + * Look up an extension by the extendee - the message it extends - and + * the extension number. + */ + getExtensionFor(extendee: DescMessage, no: number): DescExtension | undefined; + /** + * Look up a service descriptor by its fully qualified name. + */ + getService(typeName: string): DescService | undefined; +} +/** + * A registry that allows adding and removing descriptors. + */ +export interface MutableRegistry extends Registry { + /** + * Adds the given descriptor - but not types nested within - to the registry. + */ + add(desc: DescMessage | DescEnum | DescExtension | DescService): void; + /** + * Remove the given descriptor - but not types nested within - from the registry. + */ + remove(desc: DescMessage | DescEnum | DescExtension | DescService): void; +} +/** + * A registry that includes files. + */ +export interface FileRegistry extends Registry { + /** + * All files in this registry. + */ + readonly files: Iterable; + /** + * Look up a file descriptor by file name. + */ + getFile(fileName: string): DescFile | undefined; +} +/** + * Create a registry from the given inputs. + * + * An input can be: + * - Any message, enum, service, or extension descriptor, which adds just the + * descriptor for this type. + * - A file descriptor, which adds all typed defined in this file. + * - A registry, which adds all types from the registry. + * + * For duplicate descriptors (same type name), the one given last wins. + */ +export declare function createRegistry(...input: (Registry | DescFile | DescMessage | DescEnum | DescExtension | DescService)[]): Registry; +/** + * Create a registry that allows adding and removing descriptors. + */ +export declare function createMutableRegistry(...input: (Registry | DescFile | DescMessage | DescEnum | DescExtension | DescService)[]): MutableRegistry; +/** + * Create a registry (including file descriptors) from a google.protobuf.FileDescriptorSet + * message. + */ +export declare function createFileRegistry(fileDescriptorSet: FileDescriptorSet): FileRegistry; +/** + * Create a registry (including file descriptors) from a google.protobuf.FileDescriptorProto + * message. For every import, the given resolver function is called. + */ +export declare function createFileRegistry(fileDescriptorProto: FileDescriptorProto, resolve: (protoFileName: string) => FileDescriptorProto | DescFile | undefined): FileRegistry; +/** + * Create a registry (including file descriptors) from one or more registries, + * merging them. + */ +export declare function createFileRegistry(...registries: FileRegistry[]): FileRegistry; +export declare const minimumEdition: SupportedEdition, maximumEdition: SupportedEdition; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/registry.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/registry.js new file mode 100644 index 0000000000000000000000000000000000000000..2264ed6df071b30b982065f1e32f1bc11a79694d --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/registry.js @@ -0,0 +1,911 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.maximumEdition = exports.minimumEdition = void 0; +exports.createRegistry = createRegistry; +exports.createMutableRegistry = createMutableRegistry; +exports.createFileRegistry = createFileRegistry; +const descriptors_js_1 = require("./descriptors.js"); +const text_format_js_1 = require("./wire/text-format.js"); +const nested_types_js_1 = require("./reflect/nested-types.js"); +const unsafe_js_1 = require("./reflect/unsafe.js"); +const names_js_1 = require("./reflect/names.js"); +/** + * Create a registry from the given inputs. + * + * An input can be: + * - Any message, enum, service, or extension descriptor, which adds just the + * descriptor for this type. + * - A file descriptor, which adds all typed defined in this file. + * - A registry, which adds all types from the registry. + * + * For duplicate descriptors (same type name), the one given last wins. + */ +function createRegistry(...input) { + return initBaseRegistry(input); +} +/** + * Create a registry that allows adding and removing descriptors. + */ +function createMutableRegistry(...input) { + const reg = initBaseRegistry(input); + return Object.assign(Object.assign({}, reg), { remove(desc) { + var _a; + if (desc.kind == "extension") { + (_a = reg.extendees.get(desc.extendee.typeName)) === null || _a === void 0 ? void 0 : _a.delete(desc.number); + } + reg.types.delete(desc.typeName); + } }); +} +function createFileRegistry(...args) { + const registry = createBaseRegistry(); + if (!args.length) { + return registry; + } + if ("$typeName" in args[0] && + args[0].$typeName == "google.protobuf.FileDescriptorSet") { + for (const file of args[0].file) { + addFile(file, registry); + } + return registry; + } + if ("$typeName" in args[0]) { + const input = args[0]; + const resolve = args[1]; + const seen = new Set(); + function recurseDeps(file) { + const deps = []; + for (const protoFileName of file.dependency) { + if (registry.getFile(protoFileName) != undefined) { + continue; + } + if (seen.has(protoFileName)) { + continue; + } + const dep = resolve(protoFileName); + if (!dep) { + throw new Error(`Unable to resolve ${protoFileName}, imported by ${file.name}`); + } + if ("kind" in dep) { + registry.addFile(dep, false, true); + } + else { + seen.add(dep.name); + deps.push(dep); + } + } + return deps.concat(...deps.map(recurseDeps)); + } + for (const file of [input, ...recurseDeps(input)].reverse()) { + addFile(file, registry); + } + } + else { + for (const fileReg of args) { + for (const file of fileReg.files) { + registry.addFile(file); + } + } + } + return registry; +} +/** + * @private + */ +function createBaseRegistry() { + const types = new Map(); + const extendees = new Map(); + const files = new Map(); + return { + kind: "registry", + types, + extendees, + [Symbol.iterator]() { + return types.values(); + }, + get files() { + return files.values(); + }, + addFile(file, skipTypes, withDeps) { + files.set(file.proto.name, file); + if (!skipTypes) { + for (const type of (0, nested_types_js_1.nestedTypes)(file)) { + this.add(type); + } + } + if (withDeps) { + for (const f of file.dependencies) { + this.addFile(f, skipTypes, withDeps); + } + } + }, + add(desc) { + if (desc.kind == "extension") { + let numberToExt = extendees.get(desc.extendee.typeName); + if (!numberToExt) { + extendees.set(desc.extendee.typeName, + // biome-ignore lint/suspicious/noAssignInExpressions: no + (numberToExt = new Map())); + } + numberToExt.set(desc.number, desc); + } + types.set(desc.typeName, desc); + }, + get(typeName) { + return types.get(typeName); + }, + getFile(fileName) { + return files.get(fileName); + }, + getMessage(typeName) { + const t = types.get(typeName); + return (t === null || t === void 0 ? void 0 : t.kind) == "message" ? t : undefined; + }, + getEnum(typeName) { + const t = types.get(typeName); + return (t === null || t === void 0 ? void 0 : t.kind) == "enum" ? t : undefined; + }, + getExtension(typeName) { + const t = types.get(typeName); + return (t === null || t === void 0 ? void 0 : t.kind) == "extension" ? t : undefined; + }, + getExtensionFor(extendee, no) { + var _a; + return (_a = extendees.get(extendee.typeName)) === null || _a === void 0 ? void 0 : _a.get(no); + }, + getService(typeName) { + const t = types.get(typeName); + return (t === null || t === void 0 ? void 0 : t.kind) == "service" ? t : undefined; + }, + }; +} +/** + * @private + */ +function initBaseRegistry(inputs) { + const registry = createBaseRegistry(); + for (const input of inputs) { + switch (input.kind) { + case "registry": + for (const n of input) { + registry.add(n); + } + break; + case "file": + registry.addFile(input); + break; + default: + registry.add(input); + break; + } + } + return registry; +} +// bootstrap-inject google.protobuf.Edition.EDITION_PROTO2: const $name: Edition.$localName = $number; +const EDITION_PROTO2 = 998; +// bootstrap-inject google.protobuf.Edition.EDITION_PROTO3: const $name: Edition.$localName = $number; +const EDITION_PROTO3 = 999; +// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_STRING: const $name: FieldDescriptorProto_Type.$localName = $number; +const TYPE_STRING = 9; +// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_GROUP: const $name: FieldDescriptorProto_Type.$localName = $number; +const TYPE_GROUP = 10; +// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_MESSAGE: const $name: FieldDescriptorProto_Type.$localName = $number; +const TYPE_MESSAGE = 11; +// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_BYTES: const $name: FieldDescriptorProto_Type.$localName = $number; +const TYPE_BYTES = 12; +// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_ENUM: const $name: FieldDescriptorProto_Type.$localName = $number; +const TYPE_ENUM = 14; +// bootstrap-inject google.protobuf.FieldDescriptorProto.Label.LABEL_REPEATED: const $name: FieldDescriptorProto_Label.$localName = $number; +const LABEL_REPEATED = 3; +// bootstrap-inject google.protobuf.FieldDescriptorProto.Label.LABEL_REQUIRED: const $name: FieldDescriptorProto_Label.$localName = $number; +const LABEL_REQUIRED = 2; +// bootstrap-inject google.protobuf.FieldOptions.JSType.JS_STRING: const $name: FieldOptions_JSType.$localName = $number; +const JS_STRING = 1; +// bootstrap-inject google.protobuf.MethodOptions.IdempotencyLevel.IDEMPOTENCY_UNKNOWN: const $name: MethodOptions_IdempotencyLevel.$localName = $number; +const IDEMPOTENCY_UNKNOWN = 0; +// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.EXPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number; +const EXPLICIT = 1; +// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number; +const IMPLICIT = 2; +// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name: FeatureSet_FieldPresence.$localName = $number; +const LEGACY_REQUIRED = 3; +// bootstrap-inject google.protobuf.FeatureSet.RepeatedFieldEncoding.PACKED: const $name: FeatureSet_RepeatedFieldEncoding.$localName = $number; +const PACKED = 1; +// bootstrap-inject google.protobuf.FeatureSet.MessageEncoding.DELIMITED: const $name: FeatureSet_MessageEncoding.$localName = $number; +const DELIMITED = 2; +// bootstrap-inject google.protobuf.FeatureSet.EnumType.OPEN: const $name: FeatureSet_EnumType.$localName = $number; +const OPEN = 1; +// biome-ignore format: want this to read well +// bootstrap-inject defaults: EDITION_PROTO2 to EDITION_2023: export const minimumEdition: SupportedEdition = $minimumEdition, maximumEdition: SupportedEdition = $maximumEdition; +// generated from protoc v31.1 +exports.minimumEdition = 998, exports.maximumEdition = 1000; +const featureDefaults = { + // EDITION_PROTO2 + 998: { + fieldPresence: 1, // EXPLICIT, + enumType: 2, // CLOSED, + repeatedFieldEncoding: 2, // EXPANDED, + utf8Validation: 3, // NONE, + messageEncoding: 1, // LENGTH_PREFIXED, + jsonFormat: 2, // LEGACY_BEST_EFFORT, + enforceNamingStyle: 2, // STYLE_LEGACY, + defaultSymbolVisibility: 1, // EXPORT_ALL, + }, + // EDITION_PROTO3 + 999: { + fieldPresence: 2, // IMPLICIT, + enumType: 1, // OPEN, + repeatedFieldEncoding: 1, // PACKED, + utf8Validation: 2, // VERIFY, + messageEncoding: 1, // LENGTH_PREFIXED, + jsonFormat: 1, // ALLOW, + enforceNamingStyle: 2, // STYLE_LEGACY, + defaultSymbolVisibility: 1, // EXPORT_ALL, + }, + // EDITION_2023 + 1000: { + fieldPresence: 1, // EXPLICIT, + enumType: 1, // OPEN, + repeatedFieldEncoding: 1, // PACKED, + utf8Validation: 2, // VERIFY, + messageEncoding: 1, // LENGTH_PREFIXED, + jsonFormat: 1, // ALLOW, + enforceNamingStyle: 2, // STYLE_LEGACY, + defaultSymbolVisibility: 1, // EXPORT_ALL, + }, +}; +/** + * Create a descriptor for a file, add it to the registry. + */ +function addFile(proto, reg) { + var _a, _b; + const file = { + kind: "file", + proto, + deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false, + edition: getFileEdition(proto), + name: proto.name.replace(/\.proto$/, ""), + dependencies: findFileDependencies(proto, reg), + enums: [], + messages: [], + extensions: [], + services: [], + toString() { + // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above + return `file ${proto.name}`; + }, + }; + const mapEntriesStore = new Map(); + const mapEntries = { + get(typeName) { + return mapEntriesStore.get(typeName); + }, + add(desc) { + var _a; + assert(((_a = desc.proto.options) === null || _a === void 0 ? void 0 : _a.mapEntry) === true); + mapEntriesStore.set(desc.typeName, desc); + }, + }; + for (const enumProto of proto.enumType) { + addEnum(enumProto, file, undefined, reg); + } + for (const messageProto of proto.messageType) { + addMessage(messageProto, file, undefined, reg, mapEntries); + } + for (const serviceProto of proto.service) { + addService(serviceProto, file, reg); + } + addExtensions(file, reg); + for (const mapEntry of mapEntriesStore.values()) { + // to create a map field, we need access to the map entry's fields + addFields(mapEntry, reg, mapEntries); + } + for (const message of file.messages) { + addFields(message, reg, mapEntries); + addExtensions(message, reg); + } + reg.addFile(file, true); +} +/** + * Create descriptors for extensions, and add them to the message / file, + * and to our cart. + * Recurses into nested types. + */ +function addExtensions(desc, reg) { + switch (desc.kind) { + case "file": + for (const proto of desc.proto.extension) { + const ext = newField(proto, desc, reg); + desc.extensions.push(ext); + reg.add(ext); + } + break; + case "message": + for (const proto of desc.proto.extension) { + const ext = newField(proto, desc, reg); + desc.nestedExtensions.push(ext); + reg.add(ext); + } + for (const message of desc.nestedMessages) { + addExtensions(message, reg); + } + break; + } +} +/** + * Create descriptors for fields and oneof groups, and add them to the message. + * Recurses into nested types. + */ +function addFields(message, reg, mapEntries) { + const allOneofs = message.proto.oneofDecl.map((proto) => newOneof(proto, message)); + const oneofsSeen = new Set(); + for (const proto of message.proto.field) { + const oneof = findOneof(proto, allOneofs); + const field = newField(proto, message, reg, oneof, mapEntries); + message.fields.push(field); + message.field[field.localName] = field; + if (oneof === undefined) { + message.members.push(field); + } + else { + oneof.fields.push(field); + if (!oneofsSeen.has(oneof)) { + oneofsSeen.add(oneof); + message.members.push(oneof); + } + } + } + for (const oneof of allOneofs.filter((o) => oneofsSeen.has(o))) { + message.oneofs.push(oneof); + } + for (const child of message.nestedMessages) { + addFields(child, reg, mapEntries); + } +} +/** + * Create a descriptor for an enumeration, and add it our cart and to the + * parent type, if any. + */ +function addEnum(proto, file, parent, reg) { + var _a, _b, _c, _d, _e; + const sharedPrefix = findEnumSharedPrefix(proto.name, proto.value); + const desc = { + kind: "enum", + proto, + deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false, + file, + parent, + open: true, + name: proto.name, + typeName: makeTypeName(proto, parent, file), + value: {}, + values: [], + sharedPrefix, + toString() { + return `enum ${this.typeName}`; + }, + }; + desc.open = isEnumOpen(desc); + reg.add(desc); + for (const p of proto.value) { + const name = p.name; + desc.values.push( + // biome-ignore lint/suspicious/noAssignInExpressions: no + (desc.value[p.number] = { + kind: "enum_value", + proto: p, + deprecated: (_d = (_c = p.options) === null || _c === void 0 ? void 0 : _c.deprecated) !== null && _d !== void 0 ? _d : false, + parent: desc, + name, + localName: (0, names_js_1.safeObjectProperty)(sharedPrefix == undefined + ? name + : name.substring(sharedPrefix.length)), + number: p.number, + toString() { + return `enum value ${desc.typeName}.${name}`; + }, + })); + } + ((_e = parent === null || parent === void 0 ? void 0 : parent.nestedEnums) !== null && _e !== void 0 ? _e : file.enums).push(desc); +} +/** + * Create a descriptor for a message, including nested types, and add it to our + * cart. Note that this does not create descriptors fields. + */ +function addMessage(proto, file, parent, reg, mapEntries) { + var _a, _b, _c, _d; + const desc = { + kind: "message", + proto, + deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false, + file, + parent, + name: proto.name, + typeName: makeTypeName(proto, parent, file), + fields: [], + field: {}, + oneofs: [], + members: [], + nestedEnums: [], + nestedMessages: [], + nestedExtensions: [], + toString() { + return `message ${this.typeName}`; + }, + }; + if (((_c = proto.options) === null || _c === void 0 ? void 0 : _c.mapEntry) === true) { + mapEntries.add(desc); + } + else { + ((_d = parent === null || parent === void 0 ? void 0 : parent.nestedMessages) !== null && _d !== void 0 ? _d : file.messages).push(desc); + reg.add(desc); + } + for (const enumProto of proto.enumType) { + addEnum(enumProto, file, desc, reg); + } + for (const messageProto of proto.nestedType) { + addMessage(messageProto, file, desc, reg, mapEntries); + } +} +/** + * Create a descriptor for a service, including methods, and add it to our + * cart. + */ +function addService(proto, file, reg) { + var _a, _b; + const desc = { + kind: "service", + proto, + deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false, + file, + name: proto.name, + typeName: makeTypeName(proto, undefined, file), + methods: [], + method: {}, + toString() { + return `service ${this.typeName}`; + }, + }; + file.services.push(desc); + reg.add(desc); + for (const methodProto of proto.method) { + const method = newMethod(methodProto, desc, reg); + desc.methods.push(method); + desc.method[method.localName] = method; + } +} +/** + * Create a descriptor for a method. + */ +function newMethod(proto, parent, reg) { + var _a, _b, _c, _d; + let methodKind; + if (proto.clientStreaming && proto.serverStreaming) { + methodKind = "bidi_streaming"; + } + else if (proto.clientStreaming) { + methodKind = "client_streaming"; + } + else if (proto.serverStreaming) { + methodKind = "server_streaming"; + } + else { + methodKind = "unary"; + } + const input = reg.getMessage(trimLeadingDot(proto.inputType)); + const output = reg.getMessage(trimLeadingDot(proto.outputType)); + assert(input, `invalid MethodDescriptorProto: input_type ${proto.inputType} not found`); + assert(output, `invalid MethodDescriptorProto: output_type ${proto.inputType} not found`); + const name = proto.name; + return { + kind: "rpc", + proto, + deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false, + parent, + name, + localName: (0, names_js_1.safeObjectProperty)(name.length + ? (0, names_js_1.safeObjectProperty)(name[0].toLowerCase() + name.substring(1)) + : name), + methodKind, + input, + output, + idempotency: (_d = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.idempotencyLevel) !== null && _d !== void 0 ? _d : IDEMPOTENCY_UNKNOWN, + toString() { + return `rpc ${parent.typeName}.${name}`; + }, + }; +} +/** + * Create a descriptor for a oneof group. + */ +function newOneof(proto, parent) { + return { + kind: "oneof", + proto, + deprecated: false, + parent, + fields: [], + name: proto.name, + localName: (0, names_js_1.safeObjectProperty)((0, names_js_1.protoCamelCase)(proto.name)), + toString() { + return `oneof ${parent.typeName}.${this.name}`; + }, + }; +} +function newField(proto, parentOrFile, reg, oneof, mapEntries) { + var _a, _b, _c; + const isExtension = mapEntries === undefined; + const field = { + kind: "field", + proto, + deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false, + name: proto.name, + number: proto.number, + scalar: undefined, + message: undefined, + enum: undefined, + presence: getFieldPresence(proto, oneof, isExtension, parentOrFile), + listKind: undefined, + mapKind: undefined, + mapKey: undefined, + delimitedEncoding: undefined, + packed: undefined, + longAsString: false, + getDefaultValue: undefined, + }; + if (isExtension) { + // extension field + const file = parentOrFile.kind == "file" ? parentOrFile : parentOrFile.file; + const parent = parentOrFile.kind == "file" ? undefined : parentOrFile; + const typeName = makeTypeName(proto, parent, file); + field.kind = "extension"; + field.file = file; + field.parent = parent; + field.oneof = undefined; + field.typeName = typeName; + field.jsonName = `[${typeName}]`; // option json_name is not allowed on extension fields + field.toString = () => `extension ${typeName}`; + const extendee = reg.getMessage(trimLeadingDot(proto.extendee)); + assert(extendee, `invalid FieldDescriptorProto: extendee ${proto.extendee} not found`); + field.extendee = extendee; + } + else { + // regular field + const parent = parentOrFile; + assert(parent.kind == "message"); + field.parent = parent; + field.oneof = oneof; + field.localName = oneof + ? (0, names_js_1.protoCamelCase)(proto.name) + : (0, names_js_1.safeObjectProperty)((0, names_js_1.protoCamelCase)(proto.name)); + field.jsonName = proto.jsonName; + field.toString = () => `field ${parent.typeName}.${proto.name}`; + } + const label = proto.label; + const type = proto.type; + const jstype = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.jstype; + if (label === LABEL_REPEATED) { + // list or map field + const mapEntry = type == TYPE_MESSAGE + ? mapEntries === null || mapEntries === void 0 ? void 0 : mapEntries.get(trimLeadingDot(proto.typeName)) + : undefined; + if (mapEntry) { + // map field + field.fieldKind = "map"; + const { key, value } = findMapEntryFields(mapEntry); + field.mapKey = key.scalar; + field.mapKind = value.fieldKind; + field.message = value.message; + field.delimitedEncoding = false; // map fields are always LENGTH_PREFIXED + field.enum = value.enum; + field.scalar = value.scalar; + return field; + } + // list field + field.fieldKind = "list"; + switch (type) { + case TYPE_MESSAGE: + case TYPE_GROUP: + field.listKind = "message"; + field.message = reg.getMessage(trimLeadingDot(proto.typeName)); + assert(field.message); + field.delimitedEncoding = isDelimitedEncoding(proto, parentOrFile); + break; + case TYPE_ENUM: + field.listKind = "enum"; + field.enum = reg.getEnum(trimLeadingDot(proto.typeName)); + assert(field.enum); + break; + default: + field.listKind = "scalar"; + field.scalar = type; + field.longAsString = jstype == JS_STRING; + break; + } + field.packed = isPackedField(proto, parentOrFile); + return field; + } + // singular + switch (type) { + case TYPE_MESSAGE: + case TYPE_GROUP: + field.fieldKind = "message"; + field.message = reg.getMessage(trimLeadingDot(proto.typeName)); + assert(field.message, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`); + field.delimitedEncoding = isDelimitedEncoding(proto, parentOrFile); + field.getDefaultValue = () => undefined; + break; + case TYPE_ENUM: { + const enumeration = reg.getEnum(trimLeadingDot(proto.typeName)); + assert(enumeration !== undefined, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`); + field.fieldKind = "enum"; + field.enum = reg.getEnum(trimLeadingDot(proto.typeName)); + field.getDefaultValue = () => { + return (0, unsafe_js_1.unsafeIsSetExplicit)(proto, "defaultValue") + ? (0, text_format_js_1.parseTextFormatEnumValue)(enumeration, proto.defaultValue) + : undefined; + }; + break; + } + default: { + field.fieldKind = "scalar"; + field.scalar = type; + field.longAsString = jstype == JS_STRING; + field.getDefaultValue = () => { + return (0, unsafe_js_1.unsafeIsSetExplicit)(proto, "defaultValue") + ? (0, text_format_js_1.parseTextFormatScalarValue)(type, proto.defaultValue) + : undefined; + }; + break; + } + } + return field; +} +/** + * Parse the "syntax" and "edition" fields, returning one of the supported + * editions. + */ +function getFileEdition(proto) { + switch (proto.syntax) { + case "": + case "proto2": + return EDITION_PROTO2; + case "proto3": + return EDITION_PROTO3; + case "editions": + if (proto.edition in featureDefaults) { + return proto.edition; + } + throw new Error(`${proto.name}: unsupported edition`); + default: + throw new Error(`${proto.name}: unsupported syntax "${proto.syntax}"`); + } +} +/** + * Resolve dependencies of FileDescriptorProto to DescFile. + */ +function findFileDependencies(proto, reg) { + return proto.dependency.map((wantName) => { + const dep = reg.getFile(wantName); + if (!dep) { + throw new Error(`Cannot find ${wantName}, imported by ${proto.name}`); + } + return dep; + }); +} +/** + * Finds a prefix shared by enum values, for example `my_enum_` for + * `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`. + */ +function findEnumSharedPrefix(enumName, values) { + const prefix = camelToSnakeCase(enumName) + "_"; + for (const value of values) { + if (!value.name.toLowerCase().startsWith(prefix)) { + return undefined; + } + const shortName = value.name.substring(prefix.length); + if (shortName.length == 0) { + return undefined; + } + if (/^\d/.test(shortName)) { + // identifiers must not start with numbers + return undefined; + } + } + return prefix; +} +/** + * Converts lowerCamelCase or UpperCamelCase into lower_snake_case. + * This is used to find shared prefixes in an enum. + */ +function camelToSnakeCase(camel) { + return (camel.substring(0, 1) + camel.substring(1).replace(/[A-Z]/g, (c) => "_" + c)).toLowerCase(); +} +/** + * Create a fully qualified name for a protobuf type or extension field. + * + * The fully qualified name for messages, enumerations, and services is + * constructed by concatenating the package name (if present), parent + * message names (for nested types), and the type name. We omit the leading + * dot added by protobuf compilers. Examples: + * - mypackage.MyMessage + * - mypackage.MyMessage.NestedMessage + * + * The fully qualified name for extension fields is constructed by + * concatenating the package name (if present), parent message names (for + * extensions declared within a message), and the field name. Examples: + * - mypackage.extfield + * - mypackage.MyMessage.extfield + */ +function makeTypeName(proto, parent, file) { + let typeName; + if (parent) { + typeName = `${parent.typeName}.${proto.name}`; + } + else if (file.proto.package.length > 0) { + typeName = `${file.proto.package}.${proto.name}`; + } + else { + typeName = `${proto.name}`; + } + return typeName; +} +/** + * Remove the leading dot from a fully qualified type name. + */ +function trimLeadingDot(typeName) { + return typeName.startsWith(".") ? typeName.substring(1) : typeName; +} +/** + * Did the user put the field in a oneof group? + * Synthetic oneofs for proto3 optionals are ignored. + */ +function findOneof(proto, allOneofs) { + if (!(0, unsafe_js_1.unsafeIsSetExplicit)(proto, "oneofIndex")) { + return undefined; + } + if (proto.proto3Optional) { + return undefined; + } + const oneof = allOneofs[proto.oneofIndex]; + assert(oneof, `invalid FieldDescriptorProto: oneof #${proto.oneofIndex} for field #${proto.number} not found`); + return oneof; +} +/** + * Presence of the field. + * See https://protobuf.dev/programming-guides/field_presence/ + */ +function getFieldPresence(proto, oneof, isExtension, parent) { + if (proto.label == LABEL_REQUIRED) { + // proto2 required is LEGACY_REQUIRED + return LEGACY_REQUIRED; + } + if (proto.label == LABEL_REPEATED) { + // repeated fields (including maps) do not track presence + return IMPLICIT; + } + if (!!oneof || proto.proto3Optional) { + // oneof is always explicit + return EXPLICIT; + } + if (isExtension) { + // extensions always track presence + return EXPLICIT; + } + const resolved = resolveFeature("fieldPresence", { proto, parent }); + if (resolved == IMPLICIT && + (proto.type == TYPE_MESSAGE || proto.type == TYPE_GROUP)) { + // singular message field cannot be implicit + return EXPLICIT; + } + return resolved; +} +/** + * Pack this repeated field? + */ +function isPackedField(proto, parent) { + if (proto.label != LABEL_REPEATED) { + return false; + } + switch (proto.type) { + case TYPE_STRING: + case TYPE_BYTES: + case TYPE_GROUP: + case TYPE_MESSAGE: + // length-delimited types cannot be packed + return false; + } + const o = proto.options; + if (o && (0, unsafe_js_1.unsafeIsSetExplicit)(o, "packed")) { + // prefer the field option over edition features + return o.packed; + } + return (PACKED == + resolveFeature("repeatedFieldEncoding", { + proto, + parent, + })); +} +/** + * Find the key and value fields of a synthetic map entry message. + */ +function findMapEntryFields(mapEntry) { + const key = mapEntry.fields.find((f) => f.number === 1); + const value = mapEntry.fields.find((f) => f.number === 2); + assert(key && + key.fieldKind == "scalar" && + key.scalar != descriptors_js_1.ScalarType.BYTES && + key.scalar != descriptors_js_1.ScalarType.FLOAT && + key.scalar != descriptors_js_1.ScalarType.DOUBLE && + value && + value.fieldKind != "list" && + value.fieldKind != "map"); + return { key, value }; +} +/** + * Enumerations can be open or closed. + * See https://protobuf.dev/programming-guides/enum/ + */ +function isEnumOpen(desc) { + var _a; + return (OPEN == + resolveFeature("enumType", { + proto: desc.proto, + parent: (_a = desc.parent) !== null && _a !== void 0 ? _a : desc.file, + })); +} +/** + * Encode the message delimited (a.k.a. proto2 group encoding), or + * length-prefixed? + */ +function isDelimitedEncoding(proto, parent) { + if (proto.type == TYPE_GROUP) { + return true; + } + return (DELIMITED == + resolveFeature("messageEncoding", { + proto, + parent, + })); +} +function resolveFeature(name, ref) { + var _a, _b; + const featureSet = (_a = ref.proto.options) === null || _a === void 0 ? void 0 : _a.features; + if (featureSet) { + const val = featureSet[name]; + if (val != 0) { + return val; + } + } + if ("kind" in ref) { + if (ref.kind == "message") { + return resolveFeature(name, (_b = ref.parent) !== null && _b !== void 0 ? _b : ref.file); + } + const editionDefaults = featureDefaults[ref.edition]; + if (!editionDefaults) { + throw new Error(`feature default for edition ${ref.edition} not found`); + } + return editionDefaults[name]; + } + return resolveFeature(name, ref.parent); +} +/** + * Assert that condition is truthy or throw error (with message) + */ +function assert(condition, msg) { + if (!condition) { + throw new Error(msg); + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/to-binary.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/to-binary.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..236ed49ade70cdf0150699025e7550ac563363fe --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/to-binary.d.ts @@ -0,0 +1,24 @@ +import type { MessageShape } from "./types.js"; +import { BinaryWriter } from "./wire/binary-encoding.js"; +import { type DescField, type DescMessage } from "./descriptors.js"; +import type { ReflectMessage } from "./reflect/index.js"; +/** + * Options for serializing to binary data. + * + * V1 also had the option `readerFactory` for using a custom implementation to + * encode to binary. + */ +export interface BinaryWriteOptions { + /** + * Include unknown fields in the serialized output? The default behavior + * is to retain unknown fields and include them in the serialized output. + * + * For more details see https://developers.google.com/protocol-buffers/docs/proto3#unknowns + */ + writeUnknownFields: boolean; +} +export declare function toBinary(schema: Desc, message: MessageShape, options?: Partial): Uint8Array; +/** + * @private + */ +export declare function writeField(writer: BinaryWriter, opts: BinaryWriteOptions, msg: ReflectMessage, field: DescField): void; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/to-binary.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/to-binary.js new file mode 100644 index 0000000000000000000000000000000000000000..061c7ed264c30ea739c9ed6fce6e94c4e4b8709a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/to-binary.js @@ -0,0 +1,199 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.toBinary = toBinary; +exports.writeField = writeField; +const reflect_js_1 = require("./reflect/reflect.js"); +const binary_encoding_js_1 = require("./wire/binary-encoding.js"); +const descriptors_js_1 = require("./descriptors.js"); +// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name: FeatureSet_FieldPresence.$localName = $number; +const LEGACY_REQUIRED = 3; +// Default options for serializing binary data. +const writeDefaults = { + writeUnknownFields: true, +}; +function makeWriteOptions(options) { + return options ? Object.assign(Object.assign({}, writeDefaults), options) : writeDefaults; +} +function toBinary(schema, message, options) { + return writeFields(new binary_encoding_js_1.BinaryWriter(), makeWriteOptions(options), (0, reflect_js_1.reflect)(schema, message)).finish(); +} +function writeFields(writer, opts, msg) { + var _a; + for (const f of msg.sortedFields) { + if (!msg.isSet(f)) { + if (f.presence == LEGACY_REQUIRED) { + throw new Error(`cannot encode ${f} to binary: required field not set`); + } + continue; + } + writeField(writer, opts, msg, f); + } + if (opts.writeUnknownFields) { + for (const { no, wireType, data } of (_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : []) { + writer.tag(no, wireType).raw(data); + } + } + return writer; +} +/** + * @private + */ +function writeField(writer, opts, msg, field) { + var _a; + switch (field.fieldKind) { + case "scalar": + case "enum": + writeScalar(writer, msg.desc.typeName, field.name, (_a = field.scalar) !== null && _a !== void 0 ? _a : descriptors_js_1.ScalarType.INT32, field.number, msg.get(field)); + break; + case "list": + writeListField(writer, opts, field, msg.get(field)); + break; + case "message": + writeMessageField(writer, opts, field, msg.get(field)); + break; + case "map": + for (const [key, val] of msg.get(field)) { + writeMapEntry(writer, opts, field, key, val); + } + break; + } +} +function writeScalar(writer, msgName, fieldName, scalarType, fieldNo, value) { + writeScalarValue(writer.tag(fieldNo, writeTypeOfScalar(scalarType)), msgName, fieldName, scalarType, value); +} +function writeMessageField(writer, opts, field, message) { + if (field.delimitedEncoding) { + writeFields(writer.tag(field.number, binary_encoding_js_1.WireType.StartGroup), opts, message).tag(field.number, binary_encoding_js_1.WireType.EndGroup); + } + else { + writeFields(writer.tag(field.number, binary_encoding_js_1.WireType.LengthDelimited).fork(), opts, message).join(); + } +} +function writeListField(writer, opts, field, list) { + var _a; + if (field.listKind == "message") { + for (const item of list) { + writeMessageField(writer, opts, field, item); + } + return; + } + const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : descriptors_js_1.ScalarType.INT32; + if (field.packed) { + if (!list.size) { + return; + } + writer.tag(field.number, binary_encoding_js_1.WireType.LengthDelimited).fork(); + for (const item of list) { + writeScalarValue(writer, field.parent.typeName, field.name, scalarType, item); + } + writer.join(); + return; + } + for (const item of list) { + writeScalar(writer, field.parent.typeName, field.name, scalarType, field.number, item); + } +} +function writeMapEntry(writer, opts, field, key, value) { + var _a; + writer.tag(field.number, binary_encoding_js_1.WireType.LengthDelimited).fork(); + // write key, expecting key field number = 1 + writeScalar(writer, field.parent.typeName, field.name, field.mapKey, 1, key); + // write value, expecting value field number = 2 + switch (field.mapKind) { + case "scalar": + case "enum": + writeScalar(writer, field.parent.typeName, field.name, (_a = field.scalar) !== null && _a !== void 0 ? _a : descriptors_js_1.ScalarType.INT32, 2, value); + break; + case "message": + writeFields(writer.tag(2, binary_encoding_js_1.WireType.LengthDelimited).fork(), opts, value).join(); + break; + } + writer.join(); +} +function writeScalarValue(writer, msgName, fieldName, type, value) { + try { + switch (type) { + case descriptors_js_1.ScalarType.STRING: + writer.string(value); + break; + case descriptors_js_1.ScalarType.BOOL: + writer.bool(value); + break; + case descriptors_js_1.ScalarType.DOUBLE: + writer.double(value); + break; + case descriptors_js_1.ScalarType.FLOAT: + writer.float(value); + break; + case descriptors_js_1.ScalarType.INT32: + writer.int32(value); + break; + case descriptors_js_1.ScalarType.INT64: + writer.int64(value); + break; + case descriptors_js_1.ScalarType.UINT64: + writer.uint64(value); + break; + case descriptors_js_1.ScalarType.FIXED64: + writer.fixed64(value); + break; + case descriptors_js_1.ScalarType.BYTES: + writer.bytes(value); + break; + case descriptors_js_1.ScalarType.FIXED32: + writer.fixed32(value); + break; + case descriptors_js_1.ScalarType.SFIXED32: + writer.sfixed32(value); + break; + case descriptors_js_1.ScalarType.SFIXED64: + writer.sfixed64(value); + break; + case descriptors_js_1.ScalarType.SINT64: + writer.sint64(value); + break; + case descriptors_js_1.ScalarType.UINT32: + writer.uint32(value); + break; + case descriptors_js_1.ScalarType.SINT32: + writer.sint32(value); + break; + } + } + catch (e) { + if (e instanceof Error) { + throw new Error(`cannot encode field ${msgName}.${fieldName} to binary: ${e.message}`); + } + throw e; + } +} +function writeTypeOfScalar(type) { + switch (type) { + case descriptors_js_1.ScalarType.BYTES: + case descriptors_js_1.ScalarType.STRING: + return binary_encoding_js_1.WireType.LengthDelimited; + case descriptors_js_1.ScalarType.DOUBLE: + case descriptors_js_1.ScalarType.FIXED64: + case descriptors_js_1.ScalarType.SFIXED64: + return binary_encoding_js_1.WireType.Bit64; + case descriptors_js_1.ScalarType.FIXED32: + case descriptors_js_1.ScalarType.SFIXED32: + case descriptors_js_1.ScalarType.FLOAT: + return binary_encoding_js_1.WireType.Bit32; + default: + return binary_encoding_js_1.WireType.Varint; + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/to-json.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/to-json.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f15b9b53a4479839dc4300d458ae1d719befe096 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/to-json.d.ts @@ -0,0 +1,67 @@ +import { type DescEnum, type DescMessage } from "./descriptors.js"; +import type { JsonValue } from "./json-value.js"; +import type { Registry } from "./registry.js"; +import type { EnumJsonType, EnumShape, MessageJsonType, MessageShape } from "./types.js"; +/** + * Options for serializing to JSON. + */ +export interface JsonWriteOptions { + /** + * By default, fields with implicit presence are not serialized if they are + * unset. For example, an empty list field or a proto3 int32 field with 0 is + * not serialized. With this option enabled, such fields are included in the + * output. + */ + alwaysEmitImplicit: boolean; + /** + * Emit enum values as integers instead of strings: The name of an enum + * value is used by default in JSON output. An option may be provided to + * use the numeric value of the enum value instead. + */ + enumAsInteger: boolean; + /** + * Use proto field name instead of lowerCamelCase name: By default proto3 + * JSON printer should convert the field name to lowerCamelCase and use + * that as the JSON name. An implementation may provide an option to use + * proto field name as the JSON name instead. Proto3 JSON parsers are + * required to accept both the converted lowerCamelCase name and the proto + * field name. + */ + useProtoFieldName: boolean; + /** + * This option is required to write `google.protobuf.Any` and extensions + * to JSON format. + */ + registry?: Registry; +} +/** + * Options for serializing to JSON. + */ +export interface JsonWriteStringOptions extends JsonWriteOptions { + /** + * Format JSON with indentation. Indicates the number of space characters to + * be used as indentation. + * + * This option is passed to JSON.stringify as `space`. + */ + prettySpaces: number; +} +/** + * Serialize the message to a JSON value, a JavaScript value that can be + * passed to JSON.stringify(). + */ +export declare function toJson | undefined = undefined>(schema: Desc, message: MessageShape, options?: Opts): ToJson; +type ToJson> = Opts extends undefined | { + alwaysEmitImplicit?: false; + enumAsInteger?: false; + useProtoFieldName?: false; +} ? MessageJsonType : JsonValue; +/** + * Serialize the message to a JSON string. + */ +export declare function toJsonString(schema: Desc, message: MessageShape, options?: Partial): string; +/** + * Serialize a single enum value to JSON. + */ +export declare function enumToJson(descEnum: Desc, value: EnumShape): EnumJsonType; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/to-json.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/to-json.js new file mode 100644 index 0000000000000000000000000000000000000000..430f83fdf658eedb3a6ca5c4309771c62421157a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/to-json.js @@ -0,0 +1,387 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.toJson = toJson; +exports.toJsonString = toJsonString; +exports.enumToJson = enumToJson; +const descriptors_js_1 = require("./descriptors.js"); +const names_js_1 = require("./reflect/names.js"); +const reflect_js_1 = require("./reflect/reflect.js"); +const index_js_1 = require("./wkt/index.js"); +const wrappers_js_1 = require("./wkt/wrappers.js"); +const index_js_2 = require("./wire/index.js"); +const extensions_js_1 = require("./extensions.js"); +const reflect_check_js_1 = require("./reflect/reflect-check.js"); +// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name: FeatureSet_FieldPresence.$localName = $number; +const LEGACY_REQUIRED = 3; +// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number; +const IMPLICIT = 2; +// Default options for serializing to JSON. +const jsonWriteDefaults = { + alwaysEmitImplicit: false, + enumAsInteger: false, + useProtoFieldName: false, +}; +function makeWriteOptions(options) { + return options ? Object.assign(Object.assign({}, jsonWriteDefaults), options) : jsonWriteDefaults; +} +/** + * Serialize the message to a JSON value, a JavaScript value that can be + * passed to JSON.stringify(). + */ +function toJson(schema, message, options) { + return reflectToJson((0, reflect_js_1.reflect)(schema, message), makeWriteOptions(options)); +} +/** + * Serialize the message to a JSON string. + */ +function toJsonString(schema, message, options) { + var _a; + const jsonValue = toJson(schema, message, options); + return JSON.stringify(jsonValue, null, (_a = options === null || options === void 0 ? void 0 : options.prettySpaces) !== null && _a !== void 0 ? _a : 0); +} +/** + * Serialize a single enum value to JSON. + */ +function enumToJson(descEnum, value) { + var _a; + if (descEnum.typeName == "google.protobuf.NullValue") { + return null; + } + const name = (_a = descEnum.value[value]) === null || _a === void 0 ? void 0 : _a.name; + if (name === undefined) { + throw new Error(`${value} is not a value in ${descEnum}`); + } + return name; +} +function reflectToJson(msg, opts) { + var _a; + const wktJson = tryWktToJson(msg, opts); + if (wktJson !== undefined) + return wktJson; + const json = {}; + for (const f of msg.sortedFields) { + if (!msg.isSet(f)) { + if (f.presence == LEGACY_REQUIRED) { + throw new Error(`cannot encode ${f} to JSON: required field not set`); + } + if (!opts.alwaysEmitImplicit || f.presence !== IMPLICIT) { + // Fields with implicit presence omit zero values (e.g. empty string) by default + continue; + } + } + const jsonValue = fieldToJson(f, msg.get(f), opts); + if (jsonValue !== undefined) { + json[jsonName(f, opts)] = jsonValue; + } + } + if (opts.registry) { + const tagSeen = new Set(); + for (const { no } of (_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : []) { + // Same tag can appear multiple times, so we + // keep track and skip identical ones. + if (!tagSeen.has(no)) { + tagSeen.add(no); + const extension = opts.registry.getExtensionFor(msg.desc, no); + if (!extension) { + continue; + } + const value = (0, extensions_js_1.getExtension)(msg.message, extension); + const [container, field] = (0, extensions_js_1.createExtensionContainer)(extension, value); + const jsonValue = fieldToJson(field, container.get(field), opts); + if (jsonValue !== undefined) { + json[extension.jsonName] = jsonValue; + } + } + } + } + return json; +} +function fieldToJson(f, val, opts) { + switch (f.fieldKind) { + case "scalar": + return scalarToJson(f, val); + case "message": + return reflectToJson(val, opts); + case "enum": + return enumToJsonInternal(f.enum, val, opts.enumAsInteger); + case "list": + return listToJson(val, opts); + case "map": + return mapToJson(val, opts); + } +} +function mapToJson(map, opts) { + const f = map.field(); + const jsonObj = {}; + switch (f.mapKind) { + case "scalar": + for (const [entryKey, entryValue] of map) { + jsonObj[entryKey] = scalarToJson(f, entryValue); + } + break; + case "message": + for (const [entryKey, entryValue] of map) { + jsonObj[entryKey] = reflectToJson(entryValue, opts); + } + break; + case "enum": + for (const [entryKey, entryValue] of map) { + jsonObj[entryKey] = enumToJsonInternal(f.enum, entryValue, opts.enumAsInteger); + } + break; + } + return opts.alwaysEmitImplicit || map.size > 0 ? jsonObj : undefined; +} +function listToJson(list, opts) { + const f = list.field(); + const jsonArr = []; + switch (f.listKind) { + case "scalar": + for (const item of list) { + jsonArr.push(scalarToJson(f, item)); + } + break; + case "enum": + for (const item of list) { + jsonArr.push(enumToJsonInternal(f.enum, item, opts.enumAsInteger)); + } + break; + case "message": + for (const item of list) { + jsonArr.push(reflectToJson(item, opts)); + } + break; + } + return opts.alwaysEmitImplicit || jsonArr.length > 0 ? jsonArr : undefined; +} +function enumToJsonInternal(desc, value, enumAsInteger) { + var _a; + if (typeof value != "number") { + throw new Error(`cannot encode ${desc} to JSON: expected number, got ${(0, reflect_check_js_1.formatVal)(value)}`); + } + if (desc.typeName == "google.protobuf.NullValue") { + return null; + } + if (enumAsInteger) { + return value; + } + const val = desc.value[value]; + return (_a = val === null || val === void 0 ? void 0 : val.name) !== null && _a !== void 0 ? _a : value; // if we don't know the enum value, just return the number +} +function scalarToJson(field, value) { + var _a, _b, _c, _d, _e, _f; + switch (field.scalar) { + // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted. + case descriptors_js_1.ScalarType.INT32: + case descriptors_js_1.ScalarType.SFIXED32: + case descriptors_js_1.ScalarType.SINT32: + case descriptors_js_1.ScalarType.FIXED32: + case descriptors_js_1.ScalarType.UINT32: + if (typeof value != "number") { + throw new Error(`cannot encode ${field} to JSON: ${(_a = (0, reflect_check_js_1.checkField)(field, value)) === null || _a === void 0 ? void 0 : _a.message}`); + } + return value; + // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity". + // Either numbers or strings are accepted. Exponent notation is also accepted. + case descriptors_js_1.ScalarType.FLOAT: + case descriptors_js_1.ScalarType.DOUBLE: // eslint-disable-line no-fallthrough + if (typeof value != "number") { + throw new Error(`cannot encode ${field} to JSON: ${(_b = (0, reflect_check_js_1.checkField)(field, value)) === null || _b === void 0 ? void 0 : _b.message}`); + } + if (Number.isNaN(value)) + return "NaN"; + if (value === Number.POSITIVE_INFINITY) + return "Infinity"; + if (value === Number.NEGATIVE_INFINITY) + return "-Infinity"; + return value; + // string: + case descriptors_js_1.ScalarType.STRING: + if (typeof value != "string") { + throw new Error(`cannot encode ${field} to JSON: ${(_c = (0, reflect_check_js_1.checkField)(field, value)) === null || _c === void 0 ? void 0 : _c.message}`); + } + return value; + // bool: + case descriptors_js_1.ScalarType.BOOL: + if (typeof value != "boolean") { + throw new Error(`cannot encode ${field} to JSON: ${(_d = (0, reflect_check_js_1.checkField)(field, value)) === null || _d === void 0 ? void 0 : _d.message}`); + } + return value; + // JSON value will be a decimal string. Either numbers or strings are accepted. + case descriptors_js_1.ScalarType.UINT64: + case descriptors_js_1.ScalarType.FIXED64: + case descriptors_js_1.ScalarType.INT64: + case descriptors_js_1.ScalarType.SFIXED64: + case descriptors_js_1.ScalarType.SINT64: + if (typeof value != "bigint" && typeof value != "string") { + throw new Error(`cannot encode ${field} to JSON: ${(_e = (0, reflect_check_js_1.checkField)(field, value)) === null || _e === void 0 ? void 0 : _e.message}`); + } + return value.toString(); + // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings. + // Either standard or URL-safe base64 encoding with/without paddings are accepted. + case descriptors_js_1.ScalarType.BYTES: + if (value instanceof Uint8Array) { + return (0, index_js_2.base64Encode)(value); + } + throw new Error(`cannot encode ${field} to JSON: ${(_f = (0, reflect_check_js_1.checkField)(field, value)) === null || _f === void 0 ? void 0 : _f.message}`); + } +} +function jsonName(f, opts) { + return opts.useProtoFieldName ? f.name : f.jsonName; +} +// returns a json value if wkt, otherwise returns undefined. +function tryWktToJson(msg, opts) { + if (!msg.desc.typeName.startsWith("google.protobuf.")) { + return undefined; + } + switch (msg.desc.typeName) { + case "google.protobuf.Any": + return anyToJson(msg.message, opts); + case "google.protobuf.Timestamp": + return timestampToJson(msg.message); + case "google.protobuf.Duration": + return durationToJson(msg.message); + case "google.protobuf.FieldMask": + return fieldMaskToJson(msg.message); + case "google.protobuf.Struct": + return structToJson(msg.message); + case "google.protobuf.Value": + return valueToJson(msg.message); + case "google.protobuf.ListValue": + return listValueToJson(msg.message); + default: + if ((0, wrappers_js_1.isWrapperDesc)(msg.desc)) { + const valueField = msg.desc.fields[0]; + return scalarToJson(valueField, msg.get(valueField)); + } + return undefined; + } +} +function anyToJson(val, opts) { + if (val.typeUrl === "") { + return {}; + } + const { registry } = opts; + let message; + let desc; + if (registry) { + message = (0, index_js_1.anyUnpack)(val, registry); + if (message) { + desc = registry.getMessage(message.$typeName); + } + } + if (!desc || !message) { + throw new Error(`cannot encode message ${val.$typeName} to JSON: "${val.typeUrl}" is not in the type registry`); + } + let json = reflectToJson((0, reflect_js_1.reflect)(desc, message), opts); + if (desc.typeName.startsWith("google.protobuf.") || + json === null || + Array.isArray(json) || + typeof json !== "object") { + json = { value: json }; + } + json["@type"] = val.typeUrl; + return json; +} +function durationToJson(val) { + if (Number(val.seconds) > 315576000000 || + Number(val.seconds) < -315576000000) { + throw new Error(`cannot encode message ${val.$typeName} to JSON: value out of range`); + } + let text = val.seconds.toString(); + if (val.nanos !== 0) { + let nanosStr = Math.abs(val.nanos).toString(); + nanosStr = "0".repeat(9 - nanosStr.length) + nanosStr; + if (nanosStr.substring(3) === "000000") { + nanosStr = nanosStr.substring(0, 3); + } + else if (nanosStr.substring(6) === "000") { + nanosStr = nanosStr.substring(0, 6); + } + text += "." + nanosStr; + if (val.nanos < 0 && Number(val.seconds) == 0) { + text = "-" + text; + } + } + return text + "s"; +} +function fieldMaskToJson(val) { + return val.paths + .map((p) => { + if (p.match(/_[0-9]?_/g) || p.match(/[A-Z]/g)) { + throw new Error(`cannot encode message ${val.$typeName} to JSON: lowerCamelCase of path name "` + + p + + '" is irreversible'); + } + return (0, names_js_1.protoCamelCase)(p); + }) + .join(","); +} +function structToJson(val) { + const json = {}; + for (const [k, v] of Object.entries(val.fields)) { + json[k] = valueToJson(v); + } + return json; +} +function valueToJson(val) { + switch (val.kind.case) { + case "nullValue": + return null; + case "numberValue": + if (!Number.isFinite(val.kind.value)) { + throw new Error(`${val.$typeName} cannot be NaN or Infinity`); + } + return val.kind.value; + case "boolValue": + return val.kind.value; + case "stringValue": + return val.kind.value; + case "structValue": + return structToJson(val.kind.value); + case "listValue": + return listValueToJson(val.kind.value); + default: + throw new Error(`${val.$typeName} must have a value`); + } +} +function listValueToJson(val) { + return val.values.map(valueToJson); +} +function timestampToJson(val) { + const ms = Number(val.seconds) * 1000; + if (ms < Date.parse("0001-01-01T00:00:00Z") || + ms > Date.parse("9999-12-31T23:59:59Z")) { + throw new Error(`cannot encode message ${val.$typeName} to JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`); + } + if (val.nanos < 0) { + throw new Error(`cannot encode message ${val.$typeName} to JSON: nanos must not be negative`); + } + let z = "Z"; + if (val.nanos > 0) { + const nanosStr = (val.nanos + 1000000000).toString().substring(1); + if (nanosStr.substring(3) === "000000") { + z = "." + nanosStr.substring(0, 3) + "Z"; + } + else if (nanosStr.substring(6) === "000") { + z = "." + nanosStr.substring(0, 6) + "Z"; + } + else { + z = "." + nanosStr + "Z"; + } + } + return new Date(ms).toISOString().replace(".000Z", z); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/types.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/types.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..93e4effbfd1e6f30d67016325e6121d30b320d6b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/types.d.ts @@ -0,0 +1,128 @@ +import type { GenEnum as GenEnumV1, GenExtension as GenExtensionV1, GenMessage as GenMessageV1 } from "./codegenv1/types.js"; +import type { GenEnum as GenEnumV2, GenExtension as GenExtensionV2, GenMessage as GenMessageV2 } from "./codegenv2/types.js"; +import type { DescEnum, DescExtension, DescMessage, DescMethod } from "./descriptors.js"; +import type { OneofADT } from "./reflect/guard.js"; +import type { WireType } from "./wire/index.js"; +import type { JsonValue } from "./json-value.js"; +/** + * The type `Message` contains the properties shared by all messages. + */ +export type Message = { + /** + * The fully qualified Protobuf type-name of the message. + */ + readonly $typeName: TypeName; + /** + * Unknown fields and extensions stored on the message. + */ + $unknown?: UnknownField[]; +}; +/** + * Extract the message type from a message descriptor. + */ +export type MessageShape = Desc extends GenMessageV1 ? RuntimeShapeV1 : Desc extends GenMessageV2 ? RuntimeShape : Message; +/** + * Extract the message JSON type from a message descriptor. + * + * JSON types are only available for code generated with the plugin option + * `json_types=true`. If JSON types are unavailable, this type falls back to the + * `JsonValue` type. + */ +export type MessageJsonType = Desc extends GenMessageV1 ? JsonTypeV1 : Desc extends GenMessageV2 ? JsonType : JsonValue; +/** + * Extract the message Valid type from a message descriptor. + * + * Valid types are only available for code generated with the plugin option + * `valid_types`. If Valid types are unavailable, this type falls back to the + * regular message shape. + */ +export type MessageValidType = Desc extends GenMessageV1 ? RuntimeShapeV1 : Desc extends GenMessageV2 ? ValidType : Desc extends GenMessageV2 ? RuntimeShape : Message; +/** + * Extract the init type from a message descriptor. + * The init type is accepted by the function create(). + */ +export type MessageInitShape = Desc extends GenMessageV1 ? MessageInit : Desc extends GenMessageV2 ? MessageInit : Record; +/** + * Extract the enum type of from an enum descriptor. + */ +export type EnumShape = Desc extends GenEnumV1 ? RuntimeShape : Desc extends GenEnumV2 ? RuntimeShape : number; +/** + * Extract the enum JSON type from a enum descriptor. + */ +export type EnumJsonType = Desc extends GenEnumV1 ? JsonType : Desc extends GenEnumV2 ? JsonType : string | null; +/** + * Extract the value type from an extension descriptor. + */ +export type ExtensionValueShape = Desc extends GenExtensionV1 ? RuntimeShape : Desc extends GenExtensionV2 ? RuntimeShape : unknown; +/** + * Extract the type of the extended message from an extension descriptor. + */ +export type Extendee = Desc extends GenExtensionV1 ? Extendee : Desc extends GenExtensionV2 ? Extendee : Message; +/** + * Unknown fields are fields that were not recognized during parsing, or + * extension. + */ +export type UnknownField = { + readonly no: number; + readonly wireType: WireType; + readonly data: Uint8Array; +}; +/** + * Describes a streaming RPC declaration. + */ +export type DescMethodStreaming = DescMethodClientStreaming | DescMethodServerStreaming | DescMethodBiDiStreaming; +/** + * Describes a unary RPC declaration. + */ +export type DescMethodUnary = DescMethodTyped<"unary", I, O>; +/** + * Describes a server streaming RPC declaration. + */ +export type DescMethodServerStreaming = DescMethodTyped<"server_streaming", I, O>; +/** + * Describes a client streaming RPC declaration. + */ +export type DescMethodClientStreaming = DescMethodTyped<"client_streaming", I, O>; +/** + * Describes a bidi streaming RPC declaration. + */ +export type DescMethodBiDiStreaming = DescMethodTyped<"bidi_streaming", I, O>; +/** + * The init type for a message, which makes all fields optional. + * The init type is accepted by the function create(). + */ +type MessageInit = T | { + [P in keyof T as P extends "$unknown" ? never : P]?: P extends "$typeName" ? never : FieldInit; +}; +type FieldInit = F extends (Date | Uint8Array | bigint | boolean | string | number) ? F : F extends Array ? Array> : F extends ReadonlyArray ? ReadonlyArray> : F extends Message ? MessageInit : F extends OneofSelectedMessage ? { + case: C; + value: MessageInit; +} : F extends OneofADT ? F : F extends MapWithMessage ? { + [key: string | number]: MessageInit; +} : F; +type MapWithMessage = { + [key: string | number]: V; +}; +type OneofSelectedMessage = { + case: K; + value: M; +}; +type DescMethodTyped = Omit & { + /** + * One of the four available method types. + */ + readonly methodKind: K; + /** + * The message type for requests. + */ + readonly input: I; + /** + * The message type for responses. + */ + readonly output: O; +}; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/types.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/types.js new file mode 100644 index 0000000000000000000000000000000000000000..c14a1eed2ff16dd436dca87983df11fee4697f1d --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/types.js @@ -0,0 +1,15 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/base64-encoding.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/base64-encoding.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..bbe3d7dd280cae08c4b9bb30287ebd371f23c52d --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/base64-encoding.d.ts @@ -0,0 +1,23 @@ +/** + * Decodes a base64 string to a byte array. + * + * - ignores white-space, including line breaks and tabs + * - allows inner padding (can decode concatenated base64 strings) + * - does not require padding + * - understands base64url encoding: + * "-" instead of "+", + * "_" instead of "/", + * no padding + */ +export declare function base64Decode(base64Str: string): Uint8Array; +/** + * Encode a byte array to a base64 string. + * + * By default, this function uses the standard base64 encoding with padding. + * + * To encode without padding, use encoding = "std_raw". + * + * To encode with the URL encoding, use encoding = "url", which replaces the + * characters +/ by their URL-safe counterparts -_, and omits padding. + */ +export declare function base64Encode(bytes: Uint8Array, encoding?: "std" | "std_raw" | "url"): string; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/base64-encoding.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/base64-encoding.js new file mode 100644 index 0000000000000000000000000000000000000000..9a849851c81cb98ab7df391a788de865f0fbcff5 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/base64-encoding.js @@ -0,0 +1,156 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.base64Decode = base64Decode; +exports.base64Encode = base64Encode; +/** + * Decodes a base64 string to a byte array. + * + * - ignores white-space, including line breaks and tabs + * - allows inner padding (can decode concatenated base64 strings) + * - does not require padding + * - understands base64url encoding: + * "-" instead of "+", + * "_" instead of "/", + * no padding + */ +function base64Decode(base64Str) { + const table = getDecodeTable(); + // estimate byte size, not accounting for inner padding and whitespace + let es = (base64Str.length * 3) / 4; + if (base64Str[base64Str.length - 2] == "=") + es -= 2; + else if (base64Str[base64Str.length - 1] == "=") + es -= 1; + let bytes = new Uint8Array(es), bytePos = 0, // position in byte array + groupPos = 0, // position in base64 group + b, // current byte + p = 0; // previous byte + for (let i = 0; i < base64Str.length; i++) { + b = table[base64Str.charCodeAt(i)]; + if (b === undefined) { + switch (base64Str[i]) { + // @ts-ignore TS7029: Fallthrough case in switch -- ignore instead of expect-error for compiler settings without noFallthroughCasesInSwitch: true + case "=": + groupPos = 0; // reset state when padding found + case "\n": + case "\r": + case "\t": + case " ": + continue; // skip white-space, and padding + default: + throw Error("invalid base64 string"); + } + } + switch (groupPos) { + case 0: + p = b; + groupPos = 1; + break; + case 1: + bytes[bytePos++] = (p << 2) | ((b & 48) >> 4); + p = b; + groupPos = 2; + break; + case 2: + bytes[bytePos++] = ((p & 15) << 4) | ((b & 60) >> 2); + p = b; + groupPos = 3; + break; + case 3: + bytes[bytePos++] = ((p & 3) << 6) | b; + groupPos = 0; + break; + } + } + if (groupPos == 1) + throw Error("invalid base64 string"); + return bytes.subarray(0, bytePos); +} +/** + * Encode a byte array to a base64 string. + * + * By default, this function uses the standard base64 encoding with padding. + * + * To encode without padding, use encoding = "std_raw". + * + * To encode with the URL encoding, use encoding = "url", which replaces the + * characters +/ by their URL-safe counterparts -_, and omits padding. + */ +function base64Encode(bytes, encoding = "std") { + const table = getEncodeTable(encoding); + const pad = encoding == "std"; + let base64 = "", groupPos = 0, // position in base64 group + b, // current byte + p = 0; // carry over from previous byte + for (let i = 0; i < bytes.length; i++) { + b = bytes[i]; + switch (groupPos) { + case 0: + base64 += table[b >> 2]; + p = (b & 3) << 4; + groupPos = 1; + break; + case 1: + base64 += table[p | (b >> 4)]; + p = (b & 15) << 2; + groupPos = 2; + break; + case 2: + base64 += table[p | (b >> 6)]; + base64 += table[b & 63]; + groupPos = 0; + break; + } + } + // add output padding + if (groupPos) { + base64 += table[p]; + if (pad) { + base64 += "="; + if (groupPos == 1) + base64 += "="; + } + } + return base64; +} +// lookup table from base64 character to byte +let encodeTableStd; +let encodeTableUrl; +// lookup table from base64 character *code* to byte because lookup by number is fast +let decodeTable; +function getEncodeTable(encoding) { + if (!encodeTableStd) { + encodeTableStd = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split(""); + encodeTableUrl = encodeTableStd.slice(0, -2).concat("-", "_"); + } + return encoding == "url" + ? // biome-ignore lint/style/noNonNullAssertion: TS fails to narrow down + encodeTableUrl + : encodeTableStd; +} +function getDecodeTable() { + if (!decodeTable) { + decodeTable = []; + const encodeTable = getEncodeTable("std"); + for (let i = 0; i < encodeTable.length; i++) + decodeTable[encodeTable[i].charCodeAt(0)] = i; + // support base64url variants + decodeTable["-".charCodeAt(0)] = encodeTable.indexOf("+"); + decodeTable["_".charCodeAt(0)] = encodeTable.indexOf("/"); + } + return decodeTable; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/binary-encoding.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/binary-encoding.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..58f1a08a1707d3fd66ada807328a5ee9e0ca6948 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/binary-encoding.d.ts @@ -0,0 +1,264 @@ +/** + * Protobuf binary format wire types. + * + * A wire type provides just enough information to find the length of the + * following value. + * + * See https://developers.google.com/protocol-buffers/docs/encoding#structure + */ +export declare enum WireType { + /** + * Used for int32, int64, uint32, uint64, sint32, sint64, bool, enum + */ + Varint = 0, + /** + * Used for fixed64, sfixed64, double. + * Always 8 bytes with little-endian byte order. + */ + Bit64 = 1, + /** + * Used for string, bytes, embedded messages, packed repeated fields + * + * Only repeated numeric types (types which use the varint, 32-bit, + * or 64-bit wire types) can be packed. In proto3, such fields are + * packed by default. + */ + LengthDelimited = 2, + /** + * Start of a tag-delimited aggregate, such as a proto2 group, or a message + * in editions with message_encoding = DELIMITED. + */ + StartGroup = 3, + /** + * End of a tag-delimited aggregate. + */ + EndGroup = 4, + /** + * Used for fixed32, sfixed32, float. + * Always 4 bytes with little-endian byte order. + */ + Bit32 = 5 +} +/** + * Maximum value for a 32-bit floating point value (Protobuf FLOAT). + */ +export declare const FLOAT32_MAX = 3.4028234663852886e+38; +/** + * Minimum value for a 32-bit floating point value (Protobuf FLOAT). + */ +export declare const FLOAT32_MIN = -3.4028234663852886e+38; +/** + * Maximum value for an unsigned 32-bit integer (Protobuf UINT32, FIXED32). + */ +export declare const UINT32_MAX = 4294967295; +/** + * Maximum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32). + */ +export declare const INT32_MAX = 2147483647; +/** + * Minimum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32). + */ +export declare const INT32_MIN = -2147483648; +export declare class BinaryWriter { + private readonly encodeUtf8; + /** + * We cannot allocate a buffer for the entire output + * because we don't know it's size. + * + * So we collect smaller chunks of known size and + * concat them later. + * + * Use `raw()` to push data to this array. It will flush + * `buf` first. + */ + private chunks; + /** + * A growing buffer for byte values. If you don't know + * the size of the data you are writing, push to this + * array. + */ + protected buf: number[]; + /** + * Previous fork states. + */ + private stack; + constructor(encodeUtf8?: (text: string) => Uint8Array); + /** + * Return all bytes written and reset this writer. + */ + finish(): Uint8Array; + /** + * Start a new fork for length-delimited data like a message + * or a packed repeated field. + * + * Must be joined later with `join()`. + */ + fork(): this; + /** + * Join the last fork. Write its length and bytes, then + * return to the previous state. + */ + join(): this; + /** + * Writes a tag (field number and wire type). + * + * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`. + * + * Generated code should compute the tag ahead of time and call `uint32()`. + */ + tag(fieldNo: number, type: WireType): this; + /** + * Write a chunk of raw bytes. + */ + raw(chunk: Uint8Array): this; + /** + * Write a `uint32` value, an unsigned 32 bit varint. + */ + uint32(value: number): this; + /** + * Write a `int32` value, a signed 32 bit varint. + */ + int32(value: number): this; + /** + * Write a `bool` value, a variant. + */ + bool(value: boolean): this; + /** + * Write a `bytes` value, length-delimited arbitrary data. + */ + bytes(value: Uint8Array): this; + /** + * Write a `string` value, length-delimited data converted to UTF-8 text. + */ + string(value: string): this; + /** + * Write a `float` value, 32-bit floating point number. + */ + float(value: number): this; + /** + * Write a `double` value, a 64-bit floating point number. + */ + double(value: number): this; + /** + * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer. + */ + fixed32(value: number): this; + /** + * Write a `sfixed32` value, a signed, fixed-length 32-bit integer. + */ + sfixed32(value: number): this; + /** + * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint. + */ + sint32(value: number): this; + /** + * Write a `fixed64` value, a signed, fixed-length 64-bit integer. + */ + sfixed64(value: string | number | bigint): this; + /** + * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer. + */ + fixed64(value: string | number | bigint): this; + /** + * Write a `int64` value, a signed 64-bit varint. + */ + int64(value: string | number | bigint): this; + /** + * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint. + */ + sint64(value: string | number | bigint): this; + /** + * Write a `uint64` value, an unsigned 64-bit varint. + */ + uint64(value: string | number | bigint): this; +} +export declare class BinaryReader { + private readonly decodeUtf8; + /** + * Current position. + */ + pos: number; + /** + * Number of bytes available in this reader. + */ + readonly len: number; + protected readonly buf: Uint8Array; + private readonly view; + constructor(buf: Uint8Array, decodeUtf8?: (bytes: Uint8Array) => string); + /** + * Reads a tag - field number and wire type. + */ + tag(): [number, WireType]; + /** + * Skip one element and return the skipped data. + * + * When skipping StartGroup, provide the tags field number to check for + * matching field number in the EndGroup tag. + */ + skip(wireType: WireType, fieldNo?: number): Uint8Array; + protected varint64: () => [number, number]; + /** + * Throws error if position in byte array is out of range. + */ + protected assertBounds(): void; + /** + * Read a `uint32` field, an unsigned 32 bit varint. + */ + uint32: () => number; + /** + * Read a `int32` field, a signed 32 bit varint. + */ + int32(): number; + /** + * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint. + */ + sint32(): number; + /** + * Read a `int64` field, a signed 64-bit varint. + */ + int64(): bigint | string; + /** + * Read a `uint64` field, an unsigned 64-bit varint. + */ + uint64(): bigint | string; + /** + * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint. + */ + sint64(): bigint | string; + /** + * Read a `bool` field, a variant. + */ + bool(): boolean; + /** + * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer. + */ + fixed32(): number; + /** + * Read a `sfixed32` field, a signed, fixed-length 32-bit integer. + */ + sfixed32(): number; + /** + * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer. + */ + fixed64(): bigint | string; + /** + * Read a `fixed64` field, a signed, fixed-length 64-bit integer. + */ + sfixed64(): bigint | string; + /** + * Read a `float` field, 32-bit floating point number. + */ + float(): number; + /** + * Read a `double` field, a 64-bit floating point number. + */ + double(): number; + /** + * Read a `bytes` field, length-delimited arbitrary data. + */ + bytes(): Uint8Array; + /** + * Read a `string` field, length-delimited data converted to UTF-8 text. + */ + string(): string; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/binary-encoding.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/binary-encoding.js new file mode 100644 index 0000000000000000000000000000000000000000..edc1a5f2c75e839d829a1f904142e8fa08dac7a2 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/binary-encoding.js @@ -0,0 +1,515 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.BinaryReader = exports.BinaryWriter = exports.INT32_MIN = exports.INT32_MAX = exports.UINT32_MAX = exports.FLOAT32_MIN = exports.FLOAT32_MAX = exports.WireType = void 0; +const varint_js_1 = require("./varint.js"); +const proto_int64_js_1 = require("../proto-int64.js"); +const text_encoding_js_1 = require("./text-encoding.js"); +/** + * Protobuf binary format wire types. + * + * A wire type provides just enough information to find the length of the + * following value. + * + * See https://developers.google.com/protocol-buffers/docs/encoding#structure + */ +var WireType; +(function (WireType) { + /** + * Used for int32, int64, uint32, uint64, sint32, sint64, bool, enum + */ + WireType[WireType["Varint"] = 0] = "Varint"; + /** + * Used for fixed64, sfixed64, double. + * Always 8 bytes with little-endian byte order. + */ + WireType[WireType["Bit64"] = 1] = "Bit64"; + /** + * Used for string, bytes, embedded messages, packed repeated fields + * + * Only repeated numeric types (types which use the varint, 32-bit, + * or 64-bit wire types) can be packed. In proto3, such fields are + * packed by default. + */ + WireType[WireType["LengthDelimited"] = 2] = "LengthDelimited"; + /** + * Start of a tag-delimited aggregate, such as a proto2 group, or a message + * in editions with message_encoding = DELIMITED. + */ + WireType[WireType["StartGroup"] = 3] = "StartGroup"; + /** + * End of a tag-delimited aggregate. + */ + WireType[WireType["EndGroup"] = 4] = "EndGroup"; + /** + * Used for fixed32, sfixed32, float. + * Always 4 bytes with little-endian byte order. + */ + WireType[WireType["Bit32"] = 5] = "Bit32"; +})(WireType || (exports.WireType = WireType = {})); +/** + * Maximum value for a 32-bit floating point value (Protobuf FLOAT). + */ +exports.FLOAT32_MAX = 3.4028234663852886e38; +/** + * Minimum value for a 32-bit floating point value (Protobuf FLOAT). + */ +exports.FLOAT32_MIN = -3.4028234663852886e38; +/** + * Maximum value for an unsigned 32-bit integer (Protobuf UINT32, FIXED32). + */ +exports.UINT32_MAX = 0xffffffff; +/** + * Maximum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32). + */ +exports.INT32_MAX = 0x7fffffff; +/** + * Minimum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32). + */ +exports.INT32_MIN = -0x80000000; +class BinaryWriter { + constructor(encodeUtf8 = (0, text_encoding_js_1.getTextEncoding)().encodeUtf8) { + this.encodeUtf8 = encodeUtf8; + /** + * Previous fork states. + */ + this.stack = []; + this.chunks = []; + this.buf = []; + } + /** + * Return all bytes written and reset this writer. + */ + finish() { + if (this.buf.length) { + this.chunks.push(new Uint8Array(this.buf)); // flush the buffer + this.buf = []; + } + let len = 0; + for (let i = 0; i < this.chunks.length; i++) + len += this.chunks[i].length; + let bytes = new Uint8Array(len); + let offset = 0; + for (let i = 0; i < this.chunks.length; i++) { + bytes.set(this.chunks[i], offset); + offset += this.chunks[i].length; + } + this.chunks = []; + return bytes; + } + /** + * Start a new fork for length-delimited data like a message + * or a packed repeated field. + * + * Must be joined later with `join()`. + */ + fork() { + this.stack.push({ chunks: this.chunks, buf: this.buf }); + this.chunks = []; + this.buf = []; + return this; + } + /** + * Join the last fork. Write its length and bytes, then + * return to the previous state. + */ + join() { + // get chunk of fork + let chunk = this.finish(); + // restore previous state + let prev = this.stack.pop(); + if (!prev) + throw new Error("invalid state, fork stack empty"); + this.chunks = prev.chunks; + this.buf = prev.buf; + // write length of chunk as varint + this.uint32(chunk.byteLength); + return this.raw(chunk); + } + /** + * Writes a tag (field number and wire type). + * + * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`. + * + * Generated code should compute the tag ahead of time and call `uint32()`. + */ + tag(fieldNo, type) { + return this.uint32(((fieldNo << 3) | type) >>> 0); + } + /** + * Write a chunk of raw bytes. + */ + raw(chunk) { + if (this.buf.length) { + this.chunks.push(new Uint8Array(this.buf)); + this.buf = []; + } + this.chunks.push(chunk); + return this; + } + /** + * Write a `uint32` value, an unsigned 32 bit varint. + */ + uint32(value) { + assertUInt32(value); + // write value as varint 32, inlined for speed + while (value > 0x7f) { + this.buf.push((value & 0x7f) | 0x80); + value = value >>> 7; + } + this.buf.push(value); + return this; + } + /** + * Write a `int32` value, a signed 32 bit varint. + */ + int32(value) { + assertInt32(value); + (0, varint_js_1.varint32write)(value, this.buf); + return this; + } + /** + * Write a `bool` value, a variant. + */ + bool(value) { + this.buf.push(value ? 1 : 0); + return this; + } + /** + * Write a `bytes` value, length-delimited arbitrary data. + */ + bytes(value) { + this.uint32(value.byteLength); // write length of chunk as varint + return this.raw(value); + } + /** + * Write a `string` value, length-delimited data converted to UTF-8 text. + */ + string(value) { + let chunk = this.encodeUtf8(value); + this.uint32(chunk.byteLength); // write length of chunk as varint + return this.raw(chunk); + } + /** + * Write a `float` value, 32-bit floating point number. + */ + float(value) { + assertFloat32(value); + let chunk = new Uint8Array(4); + new DataView(chunk.buffer).setFloat32(0, value, true); + return this.raw(chunk); + } + /** + * Write a `double` value, a 64-bit floating point number. + */ + double(value) { + let chunk = new Uint8Array(8); + new DataView(chunk.buffer).setFloat64(0, value, true); + return this.raw(chunk); + } + /** + * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer. + */ + fixed32(value) { + assertUInt32(value); + let chunk = new Uint8Array(4); + new DataView(chunk.buffer).setUint32(0, value, true); + return this.raw(chunk); + } + /** + * Write a `sfixed32` value, a signed, fixed-length 32-bit integer. + */ + sfixed32(value) { + assertInt32(value); + let chunk = new Uint8Array(4); + new DataView(chunk.buffer).setInt32(0, value, true); + return this.raw(chunk); + } + /** + * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint. + */ + sint32(value) { + assertInt32(value); + // zigzag encode + value = ((value << 1) ^ (value >> 31)) >>> 0; + (0, varint_js_1.varint32write)(value, this.buf); + return this; + } + /** + * Write a `fixed64` value, a signed, fixed-length 64-bit integer. + */ + sfixed64(value) { + let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = proto_int64_js_1.protoInt64.enc(value); + view.setInt32(0, tc.lo, true); + view.setInt32(4, tc.hi, true); + return this.raw(chunk); + } + /** + * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer. + */ + fixed64(value) { + let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = proto_int64_js_1.protoInt64.uEnc(value); + view.setInt32(0, tc.lo, true); + view.setInt32(4, tc.hi, true); + return this.raw(chunk); + } + /** + * Write a `int64` value, a signed 64-bit varint. + */ + int64(value) { + let tc = proto_int64_js_1.protoInt64.enc(value); + (0, varint_js_1.varint64write)(tc.lo, tc.hi, this.buf); + return this; + } + /** + * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint. + */ + sint64(value) { + const tc = proto_int64_js_1.protoInt64.enc(value), + // zigzag encode + sign = tc.hi >> 31, lo = (tc.lo << 1) ^ sign, hi = ((tc.hi << 1) | (tc.lo >>> 31)) ^ sign; + (0, varint_js_1.varint64write)(lo, hi, this.buf); + return this; + } + /** + * Write a `uint64` value, an unsigned 64-bit varint. + */ + uint64(value) { + const tc = proto_int64_js_1.protoInt64.uEnc(value); + (0, varint_js_1.varint64write)(tc.lo, tc.hi, this.buf); + return this; + } +} +exports.BinaryWriter = BinaryWriter; +class BinaryReader { + constructor(buf, decodeUtf8 = (0, text_encoding_js_1.getTextEncoding)().decodeUtf8) { + this.decodeUtf8 = decodeUtf8; + this.varint64 = varint_js_1.varint64read; // dirty cast for `this` + /** + * Read a `uint32` field, an unsigned 32 bit varint. + */ + this.uint32 = varint_js_1.varint32read; + this.buf = buf; + this.len = buf.length; + this.pos = 0; + this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength); + } + /** + * Reads a tag - field number and wire type. + */ + tag() { + let tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7; + if (fieldNo <= 0 || wireType < 0 || wireType > 5) + throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType); + return [fieldNo, wireType]; + } + /** + * Skip one element and return the skipped data. + * + * When skipping StartGroup, provide the tags field number to check for + * matching field number in the EndGroup tag. + */ + skip(wireType, fieldNo) { + let start = this.pos; + switch (wireType) { + case WireType.Varint: + while (this.buf[this.pos++] & 0x80) { + // ignore + } + break; + // @ts-ignore TS7029: Fallthrough case in switch -- ignore instead of expect-error for compiler settings without noFallthroughCasesInSwitch: true + case WireType.Bit64: + this.pos += 4; + case WireType.Bit32: + this.pos += 4; + break; + case WireType.LengthDelimited: + let len = this.uint32(); + this.pos += len; + break; + case WireType.StartGroup: + for (;;) { + const [fn, wt] = this.tag(); + if (wt === WireType.EndGroup) { + if (fieldNo !== undefined && fn !== fieldNo) { + throw new Error("invalid end group tag"); + } + break; + } + this.skip(wt, fn); + } + break; + default: + throw new Error("cant skip wire type " + wireType); + } + this.assertBounds(); + return this.buf.subarray(start, this.pos); + } + /** + * Throws error if position in byte array is out of range. + */ + assertBounds() { + if (this.pos > this.len) + throw new RangeError("premature EOF"); + } + /** + * Read a `int32` field, a signed 32 bit varint. + */ + int32() { + return this.uint32() | 0; + } + /** + * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint. + */ + sint32() { + let zze = this.uint32(); + // decode zigzag + return (zze >>> 1) ^ -(zze & 1); + } + /** + * Read a `int64` field, a signed 64-bit varint. + */ + int64() { + return proto_int64_js_1.protoInt64.dec(...this.varint64()); + } + /** + * Read a `uint64` field, an unsigned 64-bit varint. + */ + uint64() { + return proto_int64_js_1.protoInt64.uDec(...this.varint64()); + } + /** + * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint. + */ + sint64() { + let [lo, hi] = this.varint64(); + // decode zig zag + let s = -(lo & 1); + lo = ((lo >>> 1) | ((hi & 1) << 31)) ^ s; + hi = (hi >>> 1) ^ s; + return proto_int64_js_1.protoInt64.dec(lo, hi); + } + /** + * Read a `bool` field, a variant. + */ + bool() { + let [lo, hi] = this.varint64(); + return lo !== 0 || hi !== 0; + } + /** + * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer. + */ + fixed32() { + // biome-ignore lint/suspicious/noAssignInExpressions: no + return this.view.getUint32((this.pos += 4) - 4, true); + } + /** + * Read a `sfixed32` field, a signed, fixed-length 32-bit integer. + */ + sfixed32() { + // biome-ignore lint/suspicious/noAssignInExpressions: no + return this.view.getInt32((this.pos += 4) - 4, true); + } + /** + * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer. + */ + fixed64() { + return proto_int64_js_1.protoInt64.uDec(this.sfixed32(), this.sfixed32()); + } + /** + * Read a `fixed64` field, a signed, fixed-length 64-bit integer. + */ + sfixed64() { + return proto_int64_js_1.protoInt64.dec(this.sfixed32(), this.sfixed32()); + } + /** + * Read a `float` field, 32-bit floating point number. + */ + float() { + // biome-ignore lint/suspicious/noAssignInExpressions: no + return this.view.getFloat32((this.pos += 4) - 4, true); + } + /** + * Read a `double` field, a 64-bit floating point number. + */ + double() { + // biome-ignore lint/suspicious/noAssignInExpressions: no + return this.view.getFloat64((this.pos += 8) - 8, true); + } + /** + * Read a `bytes` field, length-delimited arbitrary data. + */ + bytes() { + let len = this.uint32(), start = this.pos; + this.pos += len; + this.assertBounds(); + return this.buf.subarray(start, start + len); + } + /** + * Read a `string` field, length-delimited data converted to UTF-8 text. + */ + string() { + return this.decodeUtf8(this.bytes()); + } +} +exports.BinaryReader = BinaryReader; +/** + * Assert a valid signed protobuf 32-bit integer as a number or string. + */ +function assertInt32(arg) { + if (typeof arg == "string") { + arg = Number(arg); + } + else if (typeof arg != "number") { + throw new Error("invalid int32: " + typeof arg); + } + if (!Number.isInteger(arg) || + arg > exports.INT32_MAX || + arg < exports.INT32_MIN) + throw new Error("invalid int32: " + arg); +} +/** + * Assert a valid unsigned protobuf 32-bit integer as a number or string. + */ +function assertUInt32(arg) { + if (typeof arg == "string") { + arg = Number(arg); + } + else if (typeof arg != "number") { + throw new Error("invalid uint32: " + typeof arg); + } + if (!Number.isInteger(arg) || + arg > exports.UINT32_MAX || + arg < 0) + throw new Error("invalid uint32: " + arg); +} +/** + * Assert a valid protobuf float value as a number or string. + */ +function assertFloat32(arg) { + if (typeof arg == "string") { + const o = arg; + arg = Number(arg); + if (Number.isNaN(arg) && o !== "NaN") { + throw new Error("invalid float32: " + o); + } + } + else if (typeof arg != "number") { + throw new Error("invalid float32: " + typeof arg); + } + if (Number.isFinite(arg) && + (arg > exports.FLOAT32_MAX || arg < exports.FLOAT32_MIN)) + throw new Error("invalid float32: " + arg); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/index.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8630d1f3e023def8743bb0d3094182beefffa09f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/index.d.ts @@ -0,0 +1,5 @@ +export * from "./binary-encoding.js"; +export * from "./base64-encoding.js"; +export * from "./text-encoding.js"; +export * from "./text-format.js"; +export * from "./size-delimited.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/index.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/index.js new file mode 100644 index 0000000000000000000000000000000000000000..b3980e1a69645c3ebe85788ddc8d2f17107de87e --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/index.js @@ -0,0 +1,34 @@ +"use strict"; +// Copyright 2021-2025 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. +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./binary-encoding.js"), exports); +__exportStar(require("./base64-encoding.js"), exports); +__exportStar(require("./text-encoding.js"), exports); +__exportStar(require("./text-format.js"), exports); +__exportStar(require("./size-delimited.js"), exports); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/size-delimited.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/size-delimited.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..02949899c60bc27476542bad5dd2049877c33ad2 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/size-delimited.d.ts @@ -0,0 +1,51 @@ +import type { DescMessage } from "../descriptors.js"; +import type { BinaryWriteOptions } from "../to-binary.js"; +import type { MessageShape } from "../types.js"; +import type { BinaryReadOptions } from "../from-binary.js"; +/** + * Serialize a message, prefixing it with its size. + * + * A size-delimited message is a varint size in bytes, followed by exactly + * that many bytes of a message serialized with the binary format. + * + * This size-delimited format is compatible with other implementations. + * For details, see https://github.com/protocolbuffers/protobuf/issues/10229 + */ +export declare function sizeDelimitedEncode(messageDesc: Desc, message: MessageShape, options?: BinaryWriteOptions): Uint8Array; +/** + * Parse a stream of size-delimited messages. + * + * A size-delimited message is a varint size in bytes, followed by exactly + * that many bytes of a message serialized with the binary format. + * + * This size-delimited format is compatible with other implementations. + * For details, see https://github.com/protocolbuffers/protobuf/issues/10229 + */ +export declare function sizeDelimitedDecodeStream(messageDesc: Desc, iterable: AsyncIterable, options?: BinaryReadOptions): AsyncIterableIterator>; +/** + * Decodes the size from the given size-delimited message, which may be + * incomplete. + * + * Returns an object with the following properties: + * - size: The size of the delimited message in bytes + * - offset: The offset in the given byte array where the message starts + * - eof: true + * + * If the size-delimited data does not include all bytes of the varint size, + * the following object is returned: + * - size: null + * - offset: null + * - eof: false + * + * This function can be used to implement parsing of size-delimited messages + * from a stream. + */ +export declare function sizeDelimitedPeek(data: Uint8Array): { + readonly eof: false; + readonly size: number; + readonly offset: number; +} | { + readonly eof: true; + readonly size: null; + readonly offset: null; +}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/size-delimited.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/size-delimited.js new file mode 100644 index 0000000000000000000000000000000000000000..1b1c8f1d550d04af9ced7dfa9a8725db9d79f5cd --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/size-delimited.js @@ -0,0 +1,153 @@ +"use strict"; +// Copyright 2021-2025 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. +var __asyncValues = (this && this.__asyncValues) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); + function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } + function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } +}; +var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); } +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), i, q = []; + return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i; + function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; } + function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } + function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.sizeDelimitedEncode = sizeDelimitedEncode; +exports.sizeDelimitedDecodeStream = sizeDelimitedDecodeStream; +exports.sizeDelimitedPeek = sizeDelimitedPeek; +const to_binary_js_1 = require("../to-binary.js"); +const binary_encoding_js_1 = require("./binary-encoding.js"); +const from_binary_js_1 = require("../from-binary.js"); +/** + * Serialize a message, prefixing it with its size. + * + * A size-delimited message is a varint size in bytes, followed by exactly + * that many bytes of a message serialized with the binary format. + * + * This size-delimited format is compatible with other implementations. + * For details, see https://github.com/protocolbuffers/protobuf/issues/10229 + */ +function sizeDelimitedEncode(messageDesc, message, options) { + const writer = new binary_encoding_js_1.BinaryWriter(); + writer.bytes((0, to_binary_js_1.toBinary)(messageDesc, message, options)); + return writer.finish(); +} +/** + * Parse a stream of size-delimited messages. + * + * A size-delimited message is a varint size in bytes, followed by exactly + * that many bytes of a message serialized with the binary format. + * + * This size-delimited format is compatible with other implementations. + * For details, see https://github.com/protocolbuffers/protobuf/issues/10229 + */ +function sizeDelimitedDecodeStream(messageDesc, iterable, options) { + return __asyncGenerator(this, arguments, function* sizeDelimitedDecodeStream_1() { + var _a, e_1, _b, _c; + // append chunk to buffer, returning updated buffer + function append(buffer, chunk) { + const n = new Uint8Array(buffer.byteLength + chunk.byteLength); + n.set(buffer); + n.set(chunk, buffer.length); + return n; + } + let buffer = new Uint8Array(0); + try { + for (var _d = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = yield __await(iterable_1.next()), _a = iterable_1_1.done, !_a; _d = true) { + _c = iterable_1_1.value; + _d = false; + const chunk = _c; + buffer = append(buffer, chunk); + for (;;) { + const size = sizeDelimitedPeek(buffer); + if (size.eof) { + // size is incomplete, buffer more data + break; + } + if (size.offset + size.size > buffer.byteLength) { + // message is incomplete, buffer more data + break; + } + yield yield __await((0, from_binary_js_1.fromBinary)(messageDesc, buffer.subarray(size.offset, size.offset + size.size), options)); + buffer = buffer.subarray(size.offset + size.size); + } + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (!_d && !_a && (_b = iterable_1.return)) yield __await(_b.call(iterable_1)); + } + finally { if (e_1) throw e_1.error; } + } + if (buffer.byteLength > 0) { + throw new Error("incomplete data"); + } + }); +} +/** + * Decodes the size from the given size-delimited message, which may be + * incomplete. + * + * Returns an object with the following properties: + * - size: The size of the delimited message in bytes + * - offset: The offset in the given byte array where the message starts + * - eof: true + * + * If the size-delimited data does not include all bytes of the varint size, + * the following object is returned: + * - size: null + * - offset: null + * - eof: false + * + * This function can be used to implement parsing of size-delimited messages + * from a stream. + */ +function sizeDelimitedPeek(data) { + const sizeEof = { eof: true, size: null, offset: null }; + for (let i = 0; i < 10; i++) { + if (i > data.byteLength) { + return sizeEof; + } + if ((data[i] & 0x80) == 0) { + const reader = new binary_encoding_js_1.BinaryReader(data); + let size; + try { + size = reader.uint32(); + } + catch (e) { + if (e instanceof RangeError) { + return sizeEof; + } + throw e; + } + return { + eof: false, + size, + offset: reader.pos, + }; + } + } + throw new Error("invalid varint"); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-encoding.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-encoding.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..17761ea742a18ab1b476c7bd9fcad11bcdc3db3c --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-encoding.d.ts @@ -0,0 +1,26 @@ +interface TextEncoding { + /** + * Verify that the given text is valid UTF-8. + */ + checkUtf8: (text: string) => boolean; + /** + * Encode UTF-8 text to binary. + */ + encodeUtf8: (text: string) => Uint8Array; + /** + * Decode UTF-8 text from binary. + */ + decodeUtf8: (bytes: Uint8Array) => string; +} +/** + * Protobuf-ES requires the Text Encoding API to convert UTF-8 from and to + * binary. This WHATWG API is widely available, but it is not part of the + * ECMAScript standard. On runtimes where it is not available, use this + * function to provide your own implementation. + * + * Note that the Text Encoding API does not provide a way to validate UTF-8. + * Our implementation falls back to use encodeURIComponent(). + */ +export declare function configureTextEncoding(textEncoding: TextEncoding): void; +export declare function getTextEncoding(): TextEncoding; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-encoding.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-encoding.js new file mode 100644 index 0000000000000000000000000000000000000000..64acbe40d51a94fdc475fdeb65526659d9bbb85b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-encoding.js @@ -0,0 +1,54 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.configureTextEncoding = configureTextEncoding; +exports.getTextEncoding = getTextEncoding; +const symbol = Symbol.for("@bufbuild/protobuf/text-encoding"); +/** + * Protobuf-ES requires the Text Encoding API to convert UTF-8 from and to + * binary. This WHATWG API is widely available, but it is not part of the + * ECMAScript standard. On runtimes where it is not available, use this + * function to provide your own implementation. + * + * Note that the Text Encoding API does not provide a way to validate UTF-8. + * Our implementation falls back to use encodeURIComponent(). + */ +function configureTextEncoding(textEncoding) { + globalThis[symbol] = textEncoding; +} +function getTextEncoding() { + if (globalThis[symbol] == undefined) { + const te = new globalThis.TextEncoder(); + const td = new globalThis.TextDecoder(); + globalThis[symbol] = { + encodeUtf8(text) { + return te.encode(text); + }, + decodeUtf8(bytes) { + return td.decode(bytes); + }, + checkUtf8(text) { + try { + encodeURIComponent(text); + return true; + } + catch (_) { + return false; + } + }, + }; + } + return globalThis[symbol]; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-format.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-format.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..06bdbdd9590efb911a46963759d532957405a6cc --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-format.d.ts @@ -0,0 +1,13 @@ +import { type DescEnum, ScalarType } from "../descriptors.js"; +/** + * Parse an enum value from the Protobuf text format. + * + * @private + */ +export declare function parseTextFormatEnumValue(descEnum: DescEnum, value: string): number; +/** + * Parse a scalar value from the Protobuf text format. + * + * @private + */ +export declare function parseTextFormatScalarValue(type: ScalarType, value: string): number | boolean | string | bigint | Uint8Array; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-format.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-format.js new file mode 100644 index 0000000000000000000000000000000000000000..da0434e74ade954d6b5b52fb7da8c2661e84d180 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/text-format.js @@ -0,0 +1,199 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseTextFormatEnumValue = parseTextFormatEnumValue; +exports.parseTextFormatScalarValue = parseTextFormatScalarValue; +const descriptors_js_1 = require("../descriptors.js"); +const proto_int64_js_1 = require("../proto-int64.js"); +/** + * Parse an enum value from the Protobuf text format. + * + * @private + */ +function parseTextFormatEnumValue(descEnum, value) { + const enumValue = descEnum.values.find((v) => v.name === value); + if (!enumValue) { + throw new Error(`cannot parse ${descEnum} default value: ${value}`); + } + return enumValue.number; +} +/** + * Parse a scalar value from the Protobuf text format. + * + * @private + */ +function parseTextFormatScalarValue(type, value) { + switch (type) { + case descriptors_js_1.ScalarType.STRING: + return value; + case descriptors_js_1.ScalarType.BYTES: { + const u = unescapeBytesDefaultValue(value); + if (u === false) { + throw new Error(`cannot parse ${descriptors_js_1.ScalarType[type]} default value: ${value}`); + } + return u; + } + case descriptors_js_1.ScalarType.INT64: + case descriptors_js_1.ScalarType.SFIXED64: + case descriptors_js_1.ScalarType.SINT64: + return proto_int64_js_1.protoInt64.parse(value); + case descriptors_js_1.ScalarType.UINT64: + case descriptors_js_1.ScalarType.FIXED64: + return proto_int64_js_1.protoInt64.uParse(value); + case descriptors_js_1.ScalarType.DOUBLE: + case descriptors_js_1.ScalarType.FLOAT: + switch (value) { + case "inf": + return Number.POSITIVE_INFINITY; + case "-inf": + return Number.NEGATIVE_INFINITY; + case "nan": + return Number.NaN; + default: + return parseFloat(value); + } + case descriptors_js_1.ScalarType.BOOL: + return value === "true"; + case descriptors_js_1.ScalarType.INT32: + case descriptors_js_1.ScalarType.UINT32: + case descriptors_js_1.ScalarType.SINT32: + case descriptors_js_1.ScalarType.FIXED32: + case descriptors_js_1.ScalarType.SFIXED32: + return parseInt(value, 10); + } +} +/** + * Parses a text-encoded default value (proto2) of a BYTES field. + */ +function unescapeBytesDefaultValue(str) { + const b = []; + const input = { + tail: str, + c: "", + next() { + if (this.tail.length == 0) { + return false; + } + this.c = this.tail[0]; + this.tail = this.tail.substring(1); + return true; + }, + take(n) { + if (this.tail.length >= n) { + const r = this.tail.substring(0, n); + this.tail = this.tail.substring(n); + return r; + } + return false; + }, + }; + while (input.next()) { + switch (input.c) { + case "\\": + if (input.next()) { + switch (input.c) { + case "\\": + b.push(input.c.charCodeAt(0)); + break; + case "b": + b.push(0x08); + break; + case "f": + b.push(0x0c); + break; + case "n": + b.push(0x0a); + break; + case "r": + b.push(0x0d); + break; + case "t": + b.push(0x09); + break; + case "v": + b.push(0x0b); + break; + case "0": + case "1": + case "2": + case "3": + case "4": + case "5": + case "6": + case "7": { + const s = input.c; + const t = input.take(2); + if (t === false) { + return false; + } + const n = parseInt(s + t, 8); + if (Number.isNaN(n)) { + return false; + } + b.push(n); + break; + } + case "x": { + const s = input.c; + const t = input.take(2); + if (t === false) { + return false; + } + const n = parseInt(s + t, 16); + if (Number.isNaN(n)) { + return false; + } + b.push(n); + break; + } + case "u": { + const s = input.c; + const t = input.take(4); + if (t === false) { + return false; + } + const n = parseInt(s + t, 16); + if (Number.isNaN(n)) { + return false; + } + const chunk = new Uint8Array(4); + const view = new DataView(chunk.buffer); + view.setInt32(0, n, true); + b.push(chunk[0], chunk[1], chunk[2], chunk[3]); + break; + } + case "U": { + const s = input.c; + const t = input.take(8); + if (t === false) { + return false; + } + const tc = proto_int64_js_1.protoInt64.uEnc(s + t); + const chunk = new Uint8Array(8); + const view = new DataView(chunk.buffer); + view.setInt32(0, tc.lo, true); + view.setInt32(4, tc.hi, true); + b.push(chunk[0], chunk[1], chunk[2], chunk[3], chunk[4], chunk[5], chunk[6], chunk[7]); + break; + } + } + } + break; + default: + b.push(input.c.charCodeAt(0)); + } + } + return new Uint8Array(b); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/varint.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/varint.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b45ef94e9310d528c34c52f6c1bb6ebbdf951a5f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/varint.d.ts @@ -0,0 +1,70 @@ +/** + * Read a 64 bit varint as two JS numbers. + * + * Returns tuple: + * [0]: low bits + * [1]: high bits + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175 + */ +export declare function varint64read(this: T): [number, number]; +/** + * Write a 64 bit varint, given as two JS numbers, to the given bytes array. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344 + */ +export declare function varint64write(lo: number, hi: number, bytes: number[]): void; +/** + * Parse decimal string of 64 bit integer value as two JS numbers. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10 + */ +export declare function int64FromString(dec: string): { + lo: number; + hi: number; +}; +/** + * Losslessly converts a 64-bit signed integer in 32:32 split representation + * into a decimal string. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10 + */ +export declare function int64ToString(lo: number, hi: number): string; +/** + * Losslessly converts a 64-bit unsigned integer in 32:32 split representation + * into a decimal string. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10 + */ +export declare function uInt64ToString(lo: number, hi: number): string; +/** + * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)` + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144 + */ +export declare function varint32write(value: number, bytes: number[]): void; +/** + * Read an unsigned 32 bit varint. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220 + */ +export declare function varint32read(this: T): number; +type ReaderLike = { + buf: Uint8Array; + pos: number; + len: number; + assertBounds(): void; +}; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/varint.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/varint.js new file mode 100644 index 0000000000000000000000000000000000000000..a59369bd98c9d8a29457672fcc7231f94b571748 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wire/varint.js @@ -0,0 +1,322 @@ +"use strict"; +// Copyright 2008 Google Inc. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Code generated by the Protocol Buffer compiler is owned by the owner +// of the input file used when generating it. This code is not +// standalone and requires a support library to be linked with it. This +// support library is itself covered by the above license. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.varint64read = varint64read; +exports.varint64write = varint64write; +exports.int64FromString = int64FromString; +exports.int64ToString = int64ToString; +exports.uInt64ToString = uInt64ToString; +exports.varint32write = varint32write; +exports.varint32read = varint32read; +/** + * Read a 64 bit varint as two JS numbers. + * + * Returns tuple: + * [0]: low bits + * [1]: high bits + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175 + */ +function varint64read() { + let lowBits = 0; + let highBits = 0; + for (let shift = 0; shift < 28; shift += 7) { + let b = this.buf[this.pos++]; + lowBits |= (b & 0x7f) << shift; + if ((b & 0x80) == 0) { + this.assertBounds(); + return [lowBits, highBits]; + } + } + let middleByte = this.buf[this.pos++]; + // last four bits of the first 32 bit number + lowBits |= (middleByte & 0x0f) << 28; + // 3 upper bits are part of the next 32 bit number + highBits = (middleByte & 0x70) >> 4; + if ((middleByte & 0x80) == 0) { + this.assertBounds(); + return [lowBits, highBits]; + } + for (let shift = 3; shift <= 31; shift += 7) { + let b = this.buf[this.pos++]; + highBits |= (b & 0x7f) << shift; + if ((b & 0x80) == 0) { + this.assertBounds(); + return [lowBits, highBits]; + } + } + throw new Error("invalid varint"); +} +/** + * Write a 64 bit varint, given as two JS numbers, to the given bytes array. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344 + */ +function varint64write(lo, hi, bytes) { + for (let i = 0; i < 28; i = i + 7) { + const shift = lo >>> i; + const hasNext = !(shift >>> 7 == 0 && hi == 0); + const byte = (hasNext ? shift | 0x80 : shift) & 0xff; + bytes.push(byte); + if (!hasNext) { + return; + } + } + const splitBits = ((lo >>> 28) & 0x0f) | ((hi & 0x07) << 4); + const hasMoreBits = !(hi >> 3 == 0); + bytes.push((hasMoreBits ? splitBits | 0x80 : splitBits) & 0xff); + if (!hasMoreBits) { + return; + } + for (let i = 3; i < 31; i = i + 7) { + const shift = hi >>> i; + const hasNext = !(shift >>> 7 == 0); + const byte = (hasNext ? shift | 0x80 : shift) & 0xff; + bytes.push(byte); + if (!hasNext) { + return; + } + } + bytes.push((hi >>> 31) & 0x01); +} +// constants for binary math +const TWO_PWR_32_DBL = 0x100000000; +/** + * Parse decimal string of 64 bit integer value as two JS numbers. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10 + */ +function int64FromString(dec) { + // Check for minus sign. + const minus = dec[0] === "-"; + if (minus) { + dec = dec.slice(1); + } + // Work 6 decimal digits at a time, acting like we're converting base 1e6 + // digits to binary. This is safe to do with floating point math because + // Number.isSafeInteger(ALL_32_BITS * 1e6) == true. + const base = 1e6; + let lowBits = 0; + let highBits = 0; + function add1e6digit(begin, end) { + // Note: Number('') is 0. + const digit1e6 = Number(dec.slice(begin, end)); + highBits *= base; + lowBits = lowBits * base + digit1e6; + // Carry bits from lowBits to + if (lowBits >= TWO_PWR_32_DBL) { + highBits = highBits + ((lowBits / TWO_PWR_32_DBL) | 0); + lowBits = lowBits % TWO_PWR_32_DBL; + } + } + add1e6digit(-24, -18); + add1e6digit(-18, -12); + add1e6digit(-12, -6); + add1e6digit(-6); + return minus ? negate(lowBits, highBits) : newBits(lowBits, highBits); +} +/** + * Losslessly converts a 64-bit signed integer in 32:32 split representation + * into a decimal string. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10 + */ +function int64ToString(lo, hi) { + let bits = newBits(lo, hi); + // If we're treating the input as a signed value and the high bit is set, do + // a manual two's complement conversion before the decimal conversion. + const negative = bits.hi & 0x80000000; + if (negative) { + bits = negate(bits.lo, bits.hi); + } + const result = uInt64ToString(bits.lo, bits.hi); + return negative ? "-" + result : result; +} +/** + * Losslessly converts a 64-bit unsigned integer in 32:32 split representation + * into a decimal string. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10 + */ +function uInt64ToString(lo, hi) { + ({ lo, hi } = toUnsigned(lo, hi)); + // Skip the expensive conversion if the number is small enough to use the + // built-in conversions. + // Number.MAX_SAFE_INTEGER = 0x001FFFFF FFFFFFFF, thus any number with + // highBits <= 0x1FFFFF can be safely expressed with a double and retain + // integer precision. + // Proven by: Number.isSafeInteger(0x1FFFFF * 2**32 + 0xFFFFFFFF) == true. + if (hi <= 0x1fffff) { + return String(TWO_PWR_32_DBL * hi + lo); + } + // What this code is doing is essentially converting the input number from + // base-2 to base-1e7, which allows us to represent the 64-bit range with + // only 3 (very large) digits. Those digits are then trivial to convert to + // a base-10 string. + // The magic numbers used here are - + // 2^24 = 16777216 = (1,6777216) in base-1e7. + // 2^48 = 281474976710656 = (2,8147497,6710656) in base-1e7. + // Split 32:32 representation into 16:24:24 representation so our + // intermediate digits don't overflow. + const low = lo & 0xffffff; + const mid = ((lo >>> 24) | (hi << 8)) & 0xffffff; + const high = (hi >> 16) & 0xffff; + // Assemble our three base-1e7 digits, ignoring carries. The maximum + // value in a digit at this step is representable as a 48-bit integer, which + // can be stored in a 64-bit floating point number. + let digitA = low + mid * 6777216 + high * 6710656; + let digitB = mid + high * 8147497; + let digitC = high * 2; + // Apply carries from A to B and from B to C. + const base = 10000000; + if (digitA >= base) { + digitB += Math.floor(digitA / base); + digitA %= base; + } + if (digitB >= base) { + digitC += Math.floor(digitB / base); + digitB %= base; + } + // If digitC is 0, then we should have returned in the trivial code path + // at the top for non-safe integers. Given this, we can assume both digitB + // and digitA need leading zeros. + return (digitC.toString() + + decimalFrom1e7WithLeadingZeros(digitB) + + decimalFrom1e7WithLeadingZeros(digitA)); +} +function toUnsigned(lo, hi) { + return { lo: lo >>> 0, hi: hi >>> 0 }; +} +function newBits(lo, hi) { + return { lo: lo | 0, hi: hi | 0 }; +} +/** + * Returns two's compliment negation of input. + * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Signed_32-bit_integers + */ +function negate(lowBits, highBits) { + highBits = ~highBits; + if (lowBits) { + lowBits = ~lowBits + 1; + } + else { + // If lowBits is 0, then bitwise-not is 0xFFFFFFFF, + // adding 1 to that, results in 0x100000000, which leaves + // the low bits 0x0 and simply adds one to the high bits. + highBits += 1; + } + return newBits(lowBits, highBits); +} +/** + * Returns decimal representation of digit1e7 with leading zeros. + */ +const decimalFrom1e7WithLeadingZeros = (digit1e7) => { + const partial = String(digit1e7); + return "0000000".slice(partial.length) + partial; +}; +/** + * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)` + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144 + */ +function varint32write(value, bytes) { + if (value >= 0) { + // write value as varint 32 + while (value > 0x7f) { + bytes.push((value & 0x7f) | 0x80); + value = value >>> 7; + } + bytes.push(value); + } + else { + for (let i = 0; i < 9; i++) { + bytes.push((value & 127) | 128); + value = value >> 7; + } + bytes.push(1); + } +} +/** + * Read an unsigned 32 bit varint. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220 + */ +function varint32read() { + let b = this.buf[this.pos++]; + let result = b & 0x7f; + if ((b & 0x80) == 0) { + this.assertBounds(); + return result; + } + b = this.buf[this.pos++]; + result |= (b & 0x7f) << 7; + if ((b & 0x80) == 0) { + this.assertBounds(); + return result; + } + b = this.buf[this.pos++]; + result |= (b & 0x7f) << 14; + if ((b & 0x80) == 0) { + this.assertBounds(); + return result; + } + b = this.buf[this.pos++]; + result |= (b & 0x7f) << 21; + if ((b & 0x80) == 0) { + this.assertBounds(); + return result; + } + // Extract only last 4 bits + b = this.buf[this.pos++]; + result |= (b & 0x0f) << 28; + for (let readBytes = 5; (b & 0x80) !== 0 && readBytes < 10; readBytes++) + b = this.buf[this.pos++]; + if ((b & 0x80) != 0) + throw new Error("invalid varint"); + this.assertBounds(); + // Result can have 32 bits, convert it to unsigned + return result >>> 0; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/any.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/any.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5d417814b34752cd5c37a0b945343e249bde3d3f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/any.d.ts @@ -0,0 +1,38 @@ +import type { Message, MessageShape } from "../types.js"; +import type { Any } from "./gen/google/protobuf/any_pb.js"; +import type { DescMessage } from "../descriptors.js"; +import type { Registry } from "../registry.js"; +/** + * Creates a `google.protobuf.Any` from a message. + */ +export declare function anyPack(schema: Desc, message: MessageShape): Any; +/** + * Packs the message into the given any. + */ +export declare function anyPack(schema: Desc, message: MessageShape, into: Any): void; +/** + * Returns true if the Any contains the type given by schema. + */ +export declare function anyIs(any: Any, schema: DescMessage): boolean; +/** + * Returns true if the Any contains a message with the given typeName. + */ +export declare function anyIs(any: Any, typeName: string): boolean; +/** + * Unpacks the message the Any represents. + * + * Returns undefined if the Any is empty, or if packed type is not included + * in the given registry. + */ +export declare function anyUnpack(any: Any, registry: Registry): Message | undefined; +/** + * Unpacks the message the Any represents. + * + * Returns undefined if the Any is empty, or if it does not contain the type + * given by schema. + */ +export declare function anyUnpack(any: Any, schema: Desc): MessageShape | undefined; +/** + * Same as anyUnpack but unpacks into the target message. + */ +export declare function anyUnpackTo(any: Any, schema: Desc, message: MessageShape): MessageShape | undefined; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/any.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/any.js new file mode 100644 index 0000000000000000000000000000000000000000..894e4517c2fe17799e300a108790e652fcfdf46b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/any.js @@ -0,0 +1,75 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.anyPack = anyPack; +exports.anyIs = anyIs; +exports.anyUnpack = anyUnpack; +exports.anyUnpackTo = anyUnpackTo; +const any_pb_js_1 = require("./gen/google/protobuf/any_pb.js"); +const create_js_1 = require("../create.js"); +const to_binary_js_1 = require("../to-binary.js"); +const from_binary_js_1 = require("../from-binary.js"); +function anyPack(schema, message, into) { + let ret = false; + if (!into) { + into = (0, create_js_1.create)(any_pb_js_1.AnySchema); + ret = true; + } + into.value = (0, to_binary_js_1.toBinary)(schema, message); + into.typeUrl = typeNameToUrl(message.$typeName); + return ret ? into : undefined; +} +function anyIs(any, descOrTypeName) { + if (any.typeUrl === "") { + return false; + } + const want = typeof descOrTypeName == "string" + ? descOrTypeName + : descOrTypeName.typeName; + const got = typeUrlToName(any.typeUrl); + return want === got; +} +function anyUnpack(any, registryOrMessageDesc) { + if (any.typeUrl === "") { + return undefined; + } + const desc = registryOrMessageDesc.kind == "message" + ? registryOrMessageDesc + : registryOrMessageDesc.getMessage(typeUrlToName(any.typeUrl)); + if (!desc || !anyIs(any, desc)) { + return undefined; + } + return (0, from_binary_js_1.fromBinary)(desc, any.value); +} +/** + * Same as anyUnpack but unpacks into the target message. + */ +function anyUnpackTo(any, schema, message) { + if (!anyIs(any, schema)) { + return undefined; + } + return (0, from_binary_js_1.mergeFromBinary)(schema, message, any.value); +} +function typeNameToUrl(name) { + return `type.googleapis.com/${name}`; +} +function typeUrlToName(url) { + const slash = url.lastIndexOf("/"); + const name = slash >= 0 ? url.substring(slash + 1) : url; + if (!name.length) { + throw new Error(`invalid type url: ${url}`); + } + return name; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/any_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/any_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a61678ffd68cfc322d4753aca24470f239744062 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/any_pb.d.ts @@ -0,0 +1,238 @@ +import type { GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/any.proto. + */ +export declare const file_google_protobuf_any: GenFile; +/** + * `Any` contains an arbitrary serialized protocol buffer message along with a + * URL that describes the type of the serialized message. + * + * Protobuf library provides support to pack/unpack Any values in the form + * of utility functions or additional generated methods of the Any type. + * + * Example 1: Pack and unpack a message in C++. + * + * Foo foo = ...; + * Any any; + * any.PackFrom(foo); + * ... + * if (any.UnpackTo(&foo)) { + * ... + * } + * + * Example 2: Pack and unpack a message in Java. + * + * Foo foo = ...; + * Any any = Any.pack(foo); + * ... + * if (any.is(Foo.class)) { + * foo = any.unpack(Foo.class); + * } + * // or ... + * if (any.isSameTypeAs(Foo.getDefaultInstance())) { + * foo = any.unpack(Foo.getDefaultInstance()); + * } + * + * Example 3: Pack and unpack a message in Python. + * + * foo = Foo(...) + * any = Any() + * any.Pack(foo) + * ... + * if any.Is(Foo.DESCRIPTOR): + * any.Unpack(foo) + * ... + * + * Example 4: Pack and unpack a message in Go + * + * foo := &pb.Foo{...} + * any, err := anypb.New(foo) + * if err != nil { + * ... + * } + * ... + * foo := &pb.Foo{} + * if err := any.UnmarshalTo(foo); err != nil { + * ... + * } + * + * The pack methods provided by protobuf library will by default use + * 'type.googleapis.com/full.type.name' as the type URL and the unpack + * methods only use the fully qualified type name after the last '/' + * in the type URL, for example "foo.bar.com/x/y.z" will yield type + * name "y.z". + * + * JSON + * ==== + * The JSON representation of an `Any` value uses the regular + * representation of the deserialized, embedded message, with an + * additional field `@type` which contains the type URL. Example: + * + * package google.profile; + * message Person { + * string first_name = 1; + * string last_name = 2; + * } + * + * { + * "@type": "type.googleapis.com/google.profile.Person", + * "firstName": , + * "lastName": + * } + * + * If the embedded message type is well-known and has a custom JSON + * representation, that representation will be embedded adding a field + * `value` which holds the custom JSON in addition to the `@type` + * field. Example (for message [google.protobuf.Duration][]): + * + * { + * "@type": "type.googleapis.com/google.protobuf.Duration", + * "value": "1.212s" + * } + * + * + * @generated from message google.protobuf.Any + */ +export type Any = Message<"google.protobuf.Any"> & { + /** + * A URL/resource name that uniquely identifies the type of the serialized + * protocol buffer message. This string must contain at least + * one "/" character. The last segment of the URL's path must represent + * the fully qualified name of the type (as in + * `path/google.protobuf.Duration`). The name should be in a canonical form + * (e.g., leading "." is not accepted). + * + * In practice, teams usually precompile into the binary all types that they + * expect it to use in the context of Any. However, for URLs which use the + * scheme `http`, `https`, or no scheme, one can optionally set up a type + * server that maps type URLs to message definitions as follows: + * + * * If no scheme is provided, `https` is assumed. + * * An HTTP GET on the URL must yield a [google.protobuf.Type][] + * value in binary format, or produce an error. + * * Applications are allowed to cache lookup results based on the + * URL, or have them precompiled into a binary to avoid any + * lookup. Therefore, binary compatibility needs to be preserved + * on changes to types. (Use versioned type names to manage + * breaking changes.) + * + * Note: this functionality is not currently available in the official + * protobuf release, and it is not used for type URLs beginning with + * type.googleapis.com. As of May 2023, there are no widely used type server + * implementations and no plans to implement one. + * + * Schemes other than `http`, `https` (or the empty scheme) might be + * used with implementation specific semantics. + * + * + * @generated from field: string type_url = 1; + */ + typeUrl: string; + /** + * Must be a valid serialized protocol buffer of the above specified type. + * + * @generated from field: bytes value = 2; + */ + value: Uint8Array; +}; +/** + * `Any` contains an arbitrary serialized protocol buffer message along with a + * URL that describes the type of the serialized message. + * + * Protobuf library provides support to pack/unpack Any values in the form + * of utility functions or additional generated methods of the Any type. + * + * Example 1: Pack and unpack a message in C++. + * + * Foo foo = ...; + * Any any; + * any.PackFrom(foo); + * ... + * if (any.UnpackTo(&foo)) { + * ... + * } + * + * Example 2: Pack and unpack a message in Java. + * + * Foo foo = ...; + * Any any = Any.pack(foo); + * ... + * if (any.is(Foo.class)) { + * foo = any.unpack(Foo.class); + * } + * // or ... + * if (any.isSameTypeAs(Foo.getDefaultInstance())) { + * foo = any.unpack(Foo.getDefaultInstance()); + * } + * + * Example 3: Pack and unpack a message in Python. + * + * foo = Foo(...) + * any = Any() + * any.Pack(foo) + * ... + * if any.Is(Foo.DESCRIPTOR): + * any.Unpack(foo) + * ... + * + * Example 4: Pack and unpack a message in Go + * + * foo := &pb.Foo{...} + * any, err := anypb.New(foo) + * if err != nil { + * ... + * } + * ... + * foo := &pb.Foo{} + * if err := any.UnmarshalTo(foo); err != nil { + * ... + * } + * + * The pack methods provided by protobuf library will by default use + * 'type.googleapis.com/full.type.name' as the type URL and the unpack + * methods only use the fully qualified type name after the last '/' + * in the type URL, for example "foo.bar.com/x/y.z" will yield type + * name "y.z". + * + * JSON + * ==== + * The JSON representation of an `Any` value uses the regular + * representation of the deserialized, embedded message, with an + * additional field `@type` which contains the type URL. Example: + * + * package google.profile; + * message Person { + * string first_name = 1; + * string last_name = 2; + * } + * + * { + * "@type": "type.googleapis.com/google.profile.Person", + * "firstName": , + * "lastName": + * } + * + * If the embedded message type is well-known and has a custom JSON + * representation, that representation will be embedded adding a field + * `value` which holds the custom JSON in addition to the `@type` + * field. Example (for message [google.protobuf.Duration][]): + * + * { + * "@type": "type.googleapis.com/google.protobuf.Duration", + * "value": "1.212s" + * } + * + * + * @generated from message google.protobuf.Any + */ +export type AnyJson = { + "@type"?: string; +}; +/** + * Describes the message google.protobuf.Any. + * Use `create(AnySchema)` to create a new message. + */ +export declare const AnySchema: GenMessage; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/any_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/any_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..d1e5a2e7ff0d173a3bda2d054bd5608be8637925 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/any_pb.js @@ -0,0 +1,27 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.AnySchema = exports.file_google_protobuf_any = void 0; +const file_js_1 = require("../../../../codegenv2/file.js"); +const message_js_1 = require("../../../../codegenv2/message.js"); +/** + * Describes the file google/protobuf/any.proto. + */ +exports.file_google_protobuf_any = (0, file_js_1.fileDesc)("Chlnb29nbGUvcHJvdG9idWYvYW55LnByb3RvEg9nb29nbGUucHJvdG9idWYiJgoDQW55EhAKCHR5cGVfdXJsGAEgASgJEg0KBXZhbHVlGAIgASgMQnYKE2NvbS5nb29nbGUucHJvdG9idWZCCEFueVByb3RvUAFaLGdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL2FueXBiogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxLbm93blR5cGVzYgZwcm90bzM"); +/** + * Describes the message google.protobuf.Any. + * Use `create(AnySchema)` to create a new message. + */ +exports.AnySchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_any, 0); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/api_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/api_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4cfad435f1b4da0d042c60420aca4be2229bfd65 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/api_pb.d.ts @@ -0,0 +1,477 @@ +import type { GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { SourceContext, SourceContextJson } from "./source_context_pb.js"; +import type { Option, OptionJson, Syntax, SyntaxJson } from "./type_pb.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/api.proto. + */ +export declare const file_google_protobuf_api: GenFile; +/** + * Api is a light-weight descriptor for an API Interface. + * + * Interfaces are also described as "protocol buffer services" in some contexts, + * such as by the "service" keyword in a .proto file, but they are different + * from API Services, which represent a concrete implementation of an interface + * as opposed to simply a description of methods and bindings. They are also + * sometimes simply referred to as "APIs" in other contexts, such as the name of + * this message itself. See https://cloud.google.com/apis/design/glossary for + * detailed terminology. + * + * @generated from message google.protobuf.Api + */ +export type Api = Message<"google.protobuf.Api"> & { + /** + * The fully qualified name of this interface, including package name + * followed by the interface's simple name. + * + * @generated from field: string name = 1; + */ + name: string; + /** + * The methods of this interface, in unspecified order. + * + * @generated from field: repeated google.protobuf.Method methods = 2; + */ + methods: Method[]; + /** + * Any metadata attached to the interface. + * + * @generated from field: repeated google.protobuf.Option options = 3; + */ + options: Option[]; + /** + * A version string for this interface. If specified, must have the form + * `major-version.minor-version`, as in `1.10`. If the minor version is + * omitted, it defaults to zero. If the entire version field is empty, the + * major version is derived from the package name, as outlined below. If the + * field is not empty, the version in the package name will be verified to be + * consistent with what is provided here. + * + * The versioning schema uses [semantic + * versioning](http://semver.org) where the major version number + * indicates a breaking change and the minor version an additive, + * non-breaking change. Both version numbers are signals to users + * what to expect from different versions, and should be carefully + * chosen based on the product plan. + * + * The major version is also reflected in the package name of the + * interface, which must end in `v`, as in + * `google.feature.v1`. For major versions 0 and 1, the suffix can + * be omitted. Zero major versions must only be used for + * experimental, non-GA interfaces. + * + * + * @generated from field: string version = 4; + */ + version: string; + /** + * Source context for the protocol buffer service represented by this + * message. + * + * @generated from field: google.protobuf.SourceContext source_context = 5; + */ + sourceContext?: SourceContext; + /** + * Included interfaces. See [Mixin][]. + * + * @generated from field: repeated google.protobuf.Mixin mixins = 6; + */ + mixins: Mixin[]; + /** + * The source syntax of the service. + * + * @generated from field: google.protobuf.Syntax syntax = 7; + */ + syntax: Syntax; +}; +/** + * Api is a light-weight descriptor for an API Interface. + * + * Interfaces are also described as "protocol buffer services" in some contexts, + * such as by the "service" keyword in a .proto file, but they are different + * from API Services, which represent a concrete implementation of an interface + * as opposed to simply a description of methods and bindings. They are also + * sometimes simply referred to as "APIs" in other contexts, such as the name of + * this message itself. See https://cloud.google.com/apis/design/glossary for + * detailed terminology. + * + * @generated from message google.protobuf.Api + */ +export type ApiJson = { + /** + * The fully qualified name of this interface, including package name + * followed by the interface's simple name. + * + * @generated from field: string name = 1; + */ + name?: string; + /** + * The methods of this interface, in unspecified order. + * + * @generated from field: repeated google.protobuf.Method methods = 2; + */ + methods?: MethodJson[]; + /** + * Any metadata attached to the interface. + * + * @generated from field: repeated google.protobuf.Option options = 3; + */ + options?: OptionJson[]; + /** + * A version string for this interface. If specified, must have the form + * `major-version.minor-version`, as in `1.10`. If the minor version is + * omitted, it defaults to zero. If the entire version field is empty, the + * major version is derived from the package name, as outlined below. If the + * field is not empty, the version in the package name will be verified to be + * consistent with what is provided here. + * + * The versioning schema uses [semantic + * versioning](http://semver.org) where the major version number + * indicates a breaking change and the minor version an additive, + * non-breaking change. Both version numbers are signals to users + * what to expect from different versions, and should be carefully + * chosen based on the product plan. + * + * The major version is also reflected in the package name of the + * interface, which must end in `v`, as in + * `google.feature.v1`. For major versions 0 and 1, the suffix can + * be omitted. Zero major versions must only be used for + * experimental, non-GA interfaces. + * + * + * @generated from field: string version = 4; + */ + version?: string; + /** + * Source context for the protocol buffer service represented by this + * message. + * + * @generated from field: google.protobuf.SourceContext source_context = 5; + */ + sourceContext?: SourceContextJson; + /** + * Included interfaces. See [Mixin][]. + * + * @generated from field: repeated google.protobuf.Mixin mixins = 6; + */ + mixins?: MixinJson[]; + /** + * The source syntax of the service. + * + * @generated from field: google.protobuf.Syntax syntax = 7; + */ + syntax?: SyntaxJson; +}; +/** + * Describes the message google.protobuf.Api. + * Use `create(ApiSchema)` to create a new message. + */ +export declare const ApiSchema: GenMessage; +/** + * Method represents a method of an API interface. + * + * @generated from message google.protobuf.Method + */ +export type Method = Message<"google.protobuf.Method"> & { + /** + * The simple name of this method. + * + * @generated from field: string name = 1; + */ + name: string; + /** + * A URL of the input message type. + * + * @generated from field: string request_type_url = 2; + */ + requestTypeUrl: string; + /** + * If true, the request is streamed. + * + * @generated from field: bool request_streaming = 3; + */ + requestStreaming: boolean; + /** + * The URL of the output message type. + * + * @generated from field: string response_type_url = 4; + */ + responseTypeUrl: string; + /** + * If true, the response is streamed. + * + * @generated from field: bool response_streaming = 5; + */ + responseStreaming: boolean; + /** + * Any metadata attached to the method. + * + * @generated from field: repeated google.protobuf.Option options = 6; + */ + options: Option[]; + /** + * The source syntax of this method. + * + * @generated from field: google.protobuf.Syntax syntax = 7; + */ + syntax: Syntax; +}; +/** + * Method represents a method of an API interface. + * + * @generated from message google.protobuf.Method + */ +export type MethodJson = { + /** + * The simple name of this method. + * + * @generated from field: string name = 1; + */ + name?: string; + /** + * A URL of the input message type. + * + * @generated from field: string request_type_url = 2; + */ + requestTypeUrl?: string; + /** + * If true, the request is streamed. + * + * @generated from field: bool request_streaming = 3; + */ + requestStreaming?: boolean; + /** + * The URL of the output message type. + * + * @generated from field: string response_type_url = 4; + */ + responseTypeUrl?: string; + /** + * If true, the response is streamed. + * + * @generated from field: bool response_streaming = 5; + */ + responseStreaming?: boolean; + /** + * Any metadata attached to the method. + * + * @generated from field: repeated google.protobuf.Option options = 6; + */ + options?: OptionJson[]; + /** + * The source syntax of this method. + * + * @generated from field: google.protobuf.Syntax syntax = 7; + */ + syntax?: SyntaxJson; +}; +/** + * Describes the message google.protobuf.Method. + * Use `create(MethodSchema)` to create a new message. + */ +export declare const MethodSchema: GenMessage; +/** + * Declares an API Interface to be included in this interface. The including + * interface must redeclare all the methods from the included interface, but + * documentation and options are inherited as follows: + * + * - If after comment and whitespace stripping, the documentation + * string of the redeclared method is empty, it will be inherited + * from the original method. + * + * - Each annotation belonging to the service config (http, + * visibility) which is not set in the redeclared method will be + * inherited. + * + * - If an http annotation is inherited, the path pattern will be + * modified as follows. Any version prefix will be replaced by the + * version of the including interface plus the [root][] path if + * specified. + * + * Example of a simple mixin: + * + * package google.acl.v1; + * service AccessControl { + * // Get the underlying ACL object. + * rpc GetAcl(GetAclRequest) returns (Acl) { + * option (google.api.http).get = "/v1/{resource=**}:getAcl"; + * } + * } + * + * package google.storage.v2; + * service Storage { + * rpc GetAcl(GetAclRequest) returns (Acl); + * + * // Get a data record. + * rpc GetData(GetDataRequest) returns (Data) { + * option (google.api.http).get = "/v2/{resource=**}"; + * } + * } + * + * Example of a mixin configuration: + * + * apis: + * - name: google.storage.v2.Storage + * mixins: + * - name: google.acl.v1.AccessControl + * + * The mixin construct implies that all methods in `AccessControl` are + * also declared with same name and request/response types in + * `Storage`. A documentation generator or annotation processor will + * see the effective `Storage.GetAcl` method after inheriting + * documentation and annotations as follows: + * + * service Storage { + * // Get the underlying ACL object. + * rpc GetAcl(GetAclRequest) returns (Acl) { + * option (google.api.http).get = "/v2/{resource=**}:getAcl"; + * } + * ... + * } + * + * Note how the version in the path pattern changed from `v1` to `v2`. + * + * If the `root` field in the mixin is specified, it should be a + * relative path under which inherited HTTP paths are placed. Example: + * + * apis: + * - name: google.storage.v2.Storage + * mixins: + * - name: google.acl.v1.AccessControl + * root: acls + * + * This implies the following inherited HTTP annotation: + * + * service Storage { + * // Get the underlying ACL object. + * rpc GetAcl(GetAclRequest) returns (Acl) { + * option (google.api.http).get = "/v2/acls/{resource=**}:getAcl"; + * } + * ... + * } + * + * @generated from message google.protobuf.Mixin + */ +export type Mixin = Message<"google.protobuf.Mixin"> & { + /** + * The fully qualified name of the interface which is included. + * + * @generated from field: string name = 1; + */ + name: string; + /** + * If non-empty specifies a path under which inherited HTTP paths + * are rooted. + * + * @generated from field: string root = 2; + */ + root: string; +}; +/** + * Declares an API Interface to be included in this interface. The including + * interface must redeclare all the methods from the included interface, but + * documentation and options are inherited as follows: + * + * - If after comment and whitespace stripping, the documentation + * string of the redeclared method is empty, it will be inherited + * from the original method. + * + * - Each annotation belonging to the service config (http, + * visibility) which is not set in the redeclared method will be + * inherited. + * + * - If an http annotation is inherited, the path pattern will be + * modified as follows. Any version prefix will be replaced by the + * version of the including interface plus the [root][] path if + * specified. + * + * Example of a simple mixin: + * + * package google.acl.v1; + * service AccessControl { + * // Get the underlying ACL object. + * rpc GetAcl(GetAclRequest) returns (Acl) { + * option (google.api.http).get = "/v1/{resource=**}:getAcl"; + * } + * } + * + * package google.storage.v2; + * service Storage { + * rpc GetAcl(GetAclRequest) returns (Acl); + * + * // Get a data record. + * rpc GetData(GetDataRequest) returns (Data) { + * option (google.api.http).get = "/v2/{resource=**}"; + * } + * } + * + * Example of a mixin configuration: + * + * apis: + * - name: google.storage.v2.Storage + * mixins: + * - name: google.acl.v1.AccessControl + * + * The mixin construct implies that all methods in `AccessControl` are + * also declared with same name and request/response types in + * `Storage`. A documentation generator or annotation processor will + * see the effective `Storage.GetAcl` method after inheriting + * documentation and annotations as follows: + * + * service Storage { + * // Get the underlying ACL object. + * rpc GetAcl(GetAclRequest) returns (Acl) { + * option (google.api.http).get = "/v2/{resource=**}:getAcl"; + * } + * ... + * } + * + * Note how the version in the path pattern changed from `v1` to `v2`. + * + * If the `root` field in the mixin is specified, it should be a + * relative path under which inherited HTTP paths are placed. Example: + * + * apis: + * - name: google.storage.v2.Storage + * mixins: + * - name: google.acl.v1.AccessControl + * root: acls + * + * This implies the following inherited HTTP annotation: + * + * service Storage { + * // Get the underlying ACL object. + * rpc GetAcl(GetAclRequest) returns (Acl) { + * option (google.api.http).get = "/v2/acls/{resource=**}:getAcl"; + * } + * ... + * } + * + * @generated from message google.protobuf.Mixin + */ +export type MixinJson = { + /** + * The fully qualified name of the interface which is included. + * + * @generated from field: string name = 1; + */ + name?: string; + /** + * If non-empty specifies a path under which inherited HTTP paths + * are rooted. + * + * @generated from field: string root = 2; + */ + root?: string; +}; +/** + * Describes the message google.protobuf.Mixin. + * Use `create(MixinSchema)` to create a new message. + */ +export declare const MixinSchema: GenMessage; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/api_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/api_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..7d5238d5ab2e1d78d2ba6bf8febe65f46adde98e --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/api_pb.js @@ -0,0 +1,39 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.MixinSchema = exports.MethodSchema = exports.ApiSchema = exports.file_google_protobuf_api = void 0; +const file_js_1 = require("../../../../codegenv2/file.js"); +const source_context_pb_js_1 = require("./source_context_pb.js"); +const type_pb_js_1 = require("./type_pb.js"); +const message_js_1 = require("../../../../codegenv2/message.js"); +/** + * Describes the file google/protobuf/api.proto. + */ +exports.file_google_protobuf_api = (0, file_js_1.fileDesc)("Chlnb29nbGUvcHJvdG9idWYvYXBpLnByb3RvEg9nb29nbGUucHJvdG9idWYigQIKA0FwaRIMCgRuYW1lGAEgASgJEigKB21ldGhvZHMYAiADKAsyFy5nb29nbGUucHJvdG9idWYuTWV0aG9kEigKB29wdGlvbnMYAyADKAsyFy5nb29nbGUucHJvdG9idWYuT3B0aW9uEg8KB3ZlcnNpb24YBCABKAkSNgoOc291cmNlX2NvbnRleHQYBSABKAsyHi5nb29nbGUucHJvdG9idWYuU291cmNlQ29udGV4dBImCgZtaXhpbnMYBiADKAsyFi5nb29nbGUucHJvdG9idWYuTWl4aW4SJwoGc3ludGF4GAcgASgOMhcuZ29vZ2xlLnByb3RvYnVmLlN5bnRheCLVAQoGTWV0aG9kEgwKBG5hbWUYASABKAkSGAoQcmVxdWVzdF90eXBlX3VybBgCIAEoCRIZChFyZXF1ZXN0X3N0cmVhbWluZxgDIAEoCBIZChFyZXNwb25zZV90eXBlX3VybBgEIAEoCRIaChJyZXNwb25zZV9zdHJlYW1pbmcYBSABKAgSKAoHb3B0aW9ucxgGIAMoCzIXLmdvb2dsZS5wcm90b2J1Zi5PcHRpb24SJwoGc3ludGF4GAcgASgOMhcuZ29vZ2xlLnByb3RvYnVmLlN5bnRheCIjCgVNaXhpbhIMCgRuYW1lGAEgASgJEgwKBHJvb3QYAiABKAlCdgoTY29tLmdvb2dsZS5wcm90b2J1ZkIIQXBpUHJvdG9QAVosZ29vZ2xlLmdvbGFuZy5vcmcvcHJvdG9idWYvdHlwZXMva25vd24vYXBpcGKiAgNHUEKqAh5Hb29nbGUuUHJvdG9idWYuV2VsbEtub3duVHlwZXNiBnByb3RvMw", [source_context_pb_js_1.file_google_protobuf_source_context, type_pb_js_1.file_google_protobuf_type]); +/** + * Describes the message google.protobuf.Api. + * Use `create(ApiSchema)` to create a new message. + */ +exports.ApiSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_api, 0); +/** + * Describes the message google.protobuf.Method. + * Use `create(MethodSchema)` to create a new message. + */ +exports.MethodSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_api, 1); +/** + * Describes the message google.protobuf.Mixin. + * Use `create(MixinSchema)` to create a new message. + */ +exports.MixinSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_api, 2); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/compiler/plugin_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/compiler/plugin_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2c3eaf6d8c630105a7fb17d2cd2a944234fcbe14 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/compiler/plugin_pb.d.ts @@ -0,0 +1,490 @@ +import type { GenEnum, GenFile, GenMessage } from "../../../../../codegenv2/types.js"; +import type { FileDescriptorProto, FileDescriptorProtoJson, GeneratedCodeInfo, GeneratedCodeInfoJson } from "../descriptor_pb.js"; +import type { Message } from "../../../../../types.js"; +/** + * Describes the file google/protobuf/compiler/plugin.proto. + */ +export declare const file_google_protobuf_compiler_plugin: GenFile; +/** + * The version number of protocol compiler. + * + * @generated from message google.protobuf.compiler.Version + */ +export type Version = Message<"google.protobuf.compiler.Version"> & { + /** + * @generated from field: optional int32 major = 1; + */ + major: number; + /** + * @generated from field: optional int32 minor = 2; + */ + minor: number; + /** + * @generated from field: optional int32 patch = 3; + */ + patch: number; + /** + * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should + * be empty for mainline stable releases. + * + * @generated from field: optional string suffix = 4; + */ + suffix: string; +}; +/** + * The version number of protocol compiler. + * + * @generated from message google.protobuf.compiler.Version + */ +export type VersionJson = { + /** + * @generated from field: optional int32 major = 1; + */ + major?: number; + /** + * @generated from field: optional int32 minor = 2; + */ + minor?: number; + /** + * @generated from field: optional int32 patch = 3; + */ + patch?: number; + /** + * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should + * be empty for mainline stable releases. + * + * @generated from field: optional string suffix = 4; + */ + suffix?: string; +}; +/** + * Describes the message google.protobuf.compiler.Version. + * Use `create(VersionSchema)` to create a new message. + */ +export declare const VersionSchema: GenMessage; +/** + * An encoded CodeGeneratorRequest is written to the plugin's stdin. + * + * @generated from message google.protobuf.compiler.CodeGeneratorRequest + */ +export type CodeGeneratorRequest = Message<"google.protobuf.compiler.CodeGeneratorRequest"> & { + /** + * The .proto files that were explicitly listed on the command-line. The + * code generator should generate code only for these files. Each file's + * descriptor will be included in proto_file, below. + * + * @generated from field: repeated string file_to_generate = 1; + */ + fileToGenerate: string[]; + /** + * The generator parameter passed on the command-line. + * + * @generated from field: optional string parameter = 2; + */ + parameter: string; + /** + * FileDescriptorProtos for all files in files_to_generate and everything + * they import. The files will appear in topological order, so each file + * appears before any file that imports it. + * + * Note: the files listed in files_to_generate will include runtime-retention + * options only, but all other files will include source-retention options. + * The source_file_descriptors field below is available in case you need + * source-retention options for files_to_generate. + * + * protoc guarantees that all proto_files will be written after + * the fields above, even though this is not technically guaranteed by the + * protobuf wire format. This theoretically could allow a plugin to stream + * in the FileDescriptorProtos and handle them one by one rather than read + * the entire set into memory at once. However, as of this writing, this + * is not similarly optimized on protoc's end -- it will store all fields in + * memory at once before sending them to the plugin. + * + * Type names of fields and extensions in the FileDescriptorProto are always + * fully qualified. + * + * @generated from field: repeated google.protobuf.FileDescriptorProto proto_file = 15; + */ + protoFile: FileDescriptorProto[]; + /** + * File descriptors with all options, including source-retention options. + * These descriptors are only provided for the files listed in + * files_to_generate. + * + * @generated from field: repeated google.protobuf.FileDescriptorProto source_file_descriptors = 17; + */ + sourceFileDescriptors: FileDescriptorProto[]; + /** + * The version number of protocol compiler. + * + * @generated from field: optional google.protobuf.compiler.Version compiler_version = 3; + */ + compilerVersion?: Version; +}; +/** + * An encoded CodeGeneratorRequest is written to the plugin's stdin. + * + * @generated from message google.protobuf.compiler.CodeGeneratorRequest + */ +export type CodeGeneratorRequestJson = { + /** + * The .proto files that were explicitly listed on the command-line. The + * code generator should generate code only for these files. Each file's + * descriptor will be included in proto_file, below. + * + * @generated from field: repeated string file_to_generate = 1; + */ + fileToGenerate?: string[]; + /** + * The generator parameter passed on the command-line. + * + * @generated from field: optional string parameter = 2; + */ + parameter?: string; + /** + * FileDescriptorProtos for all files in files_to_generate and everything + * they import. The files will appear in topological order, so each file + * appears before any file that imports it. + * + * Note: the files listed in files_to_generate will include runtime-retention + * options only, but all other files will include source-retention options. + * The source_file_descriptors field below is available in case you need + * source-retention options for files_to_generate. + * + * protoc guarantees that all proto_files will be written after + * the fields above, even though this is not technically guaranteed by the + * protobuf wire format. This theoretically could allow a plugin to stream + * in the FileDescriptorProtos and handle them one by one rather than read + * the entire set into memory at once. However, as of this writing, this + * is not similarly optimized on protoc's end -- it will store all fields in + * memory at once before sending them to the plugin. + * + * Type names of fields and extensions in the FileDescriptorProto are always + * fully qualified. + * + * @generated from field: repeated google.protobuf.FileDescriptorProto proto_file = 15; + */ + protoFile?: FileDescriptorProtoJson[]; + /** + * File descriptors with all options, including source-retention options. + * These descriptors are only provided for the files listed in + * files_to_generate. + * + * @generated from field: repeated google.protobuf.FileDescriptorProto source_file_descriptors = 17; + */ + sourceFileDescriptors?: FileDescriptorProtoJson[]; + /** + * The version number of protocol compiler. + * + * @generated from field: optional google.protobuf.compiler.Version compiler_version = 3; + */ + compilerVersion?: VersionJson; +}; +/** + * Describes the message google.protobuf.compiler.CodeGeneratorRequest. + * Use `create(CodeGeneratorRequestSchema)` to create a new message. + */ +export declare const CodeGeneratorRequestSchema: GenMessage; +/** + * The plugin writes an encoded CodeGeneratorResponse to stdout. + * + * @generated from message google.protobuf.compiler.CodeGeneratorResponse + */ +export type CodeGeneratorResponse = Message<"google.protobuf.compiler.CodeGeneratorResponse"> & { + /** + * Error message. If non-empty, code generation failed. The plugin process + * should exit with status code zero even if it reports an error in this way. + * + * This should be used to indicate errors in .proto files which prevent the + * code generator from generating correct code. Errors which indicate a + * problem in protoc itself -- such as the input CodeGeneratorRequest being + * unparseable -- should be reported by writing a message to stderr and + * exiting with a non-zero status code. + * + * @generated from field: optional string error = 1; + */ + error: string; + /** + * A bitmask of supported features that the code generator supports. + * This is a bitwise "or" of values from the Feature enum. + * + * @generated from field: optional uint64 supported_features = 2; + */ + supportedFeatures: bigint; + /** + * The minimum edition this plugin supports. This will be treated as an + * Edition enum, but we want to allow unknown values. It should be specified + * according the edition enum value, *not* the edition number. Only takes + * effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + * + * @generated from field: optional int32 minimum_edition = 3; + */ + minimumEdition: number; + /** + * The maximum edition this plugin supports. This will be treated as an + * Edition enum, but we want to allow unknown values. It should be specified + * according the edition enum value, *not* the edition number. Only takes + * effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + * + * @generated from field: optional int32 maximum_edition = 4; + */ + maximumEdition: number; + /** + * @generated from field: repeated google.protobuf.compiler.CodeGeneratorResponse.File file = 15; + */ + file: CodeGeneratorResponse_File[]; +}; +/** + * The plugin writes an encoded CodeGeneratorResponse to stdout. + * + * @generated from message google.protobuf.compiler.CodeGeneratorResponse + */ +export type CodeGeneratorResponseJson = { + /** + * Error message. If non-empty, code generation failed. The plugin process + * should exit with status code zero even if it reports an error in this way. + * + * This should be used to indicate errors in .proto files which prevent the + * code generator from generating correct code. Errors which indicate a + * problem in protoc itself -- such as the input CodeGeneratorRequest being + * unparseable -- should be reported by writing a message to stderr and + * exiting with a non-zero status code. + * + * @generated from field: optional string error = 1; + */ + error?: string; + /** + * A bitmask of supported features that the code generator supports. + * This is a bitwise "or" of values from the Feature enum. + * + * @generated from field: optional uint64 supported_features = 2; + */ + supportedFeatures?: string; + /** + * The minimum edition this plugin supports. This will be treated as an + * Edition enum, but we want to allow unknown values. It should be specified + * according the edition enum value, *not* the edition number. Only takes + * effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + * + * @generated from field: optional int32 minimum_edition = 3; + */ + minimumEdition?: number; + /** + * The maximum edition this plugin supports. This will be treated as an + * Edition enum, but we want to allow unknown values. It should be specified + * according the edition enum value, *not* the edition number. Only takes + * effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + * + * @generated from field: optional int32 maximum_edition = 4; + */ + maximumEdition?: number; + /** + * @generated from field: repeated google.protobuf.compiler.CodeGeneratorResponse.File file = 15; + */ + file?: CodeGeneratorResponse_FileJson[]; +}; +/** + * Describes the message google.protobuf.compiler.CodeGeneratorResponse. + * Use `create(CodeGeneratorResponseSchema)` to create a new message. + */ +export declare const CodeGeneratorResponseSchema: GenMessage; +/** + * Represents a single generated file. + * + * @generated from message google.protobuf.compiler.CodeGeneratorResponse.File + */ +export type CodeGeneratorResponse_File = Message<"google.protobuf.compiler.CodeGeneratorResponse.File"> & { + /** + * The file name, relative to the output directory. The name must not + * contain "." or ".." components and must be relative, not be absolute (so, + * the file cannot lie outside the output directory). "/" must be used as + * the path separator, not "\". + * + * If the name is omitted, the content will be appended to the previous + * file. This allows the generator to break large files into small chunks, + * and allows the generated text to be streamed back to protoc so that large + * files need not reside completely in memory at one time. Note that as of + * this writing protoc does not optimize for this -- it will read the entire + * CodeGeneratorResponse before writing files to disk. + * + * @generated from field: optional string name = 1; + */ + name: string; + /** + * If non-empty, indicates that the named file should already exist, and the + * content here is to be inserted into that file at a defined insertion + * point. This feature allows a code generator to extend the output + * produced by another code generator. The original generator may provide + * insertion points by placing special annotations in the file that look + * like: + * @@protoc_insertion_point(NAME) + * The annotation can have arbitrary text before and after it on the line, + * which allows it to be placed in a comment. NAME should be replaced with + * an identifier naming the point -- this is what other generators will use + * as the insertion_point. Code inserted at this point will be placed + * immediately above the line containing the insertion point (thus multiple + * insertions to the same point will come out in the order they were added). + * The double-@ is intended to make it unlikely that the generated code + * could contain things that look like insertion points by accident. + * + * For example, the C++ code generator places the following line in the + * .pb.h files that it generates: + * // @@protoc_insertion_point(namespace_scope) + * This line appears within the scope of the file's package namespace, but + * outside of any particular class. Another plugin can then specify the + * insertion_point "namespace_scope" to generate additional classes or + * other declarations that should be placed in this scope. + * + * Note that if the line containing the insertion point begins with + * whitespace, the same whitespace will be added to every line of the + * inserted text. This is useful for languages like Python, where + * indentation matters. In these languages, the insertion point comment + * should be indented the same amount as any inserted code will need to be + * in order to work correctly in that context. + * + * The code generator that generates the initial file and the one which + * inserts into it must both run as part of a single invocation of protoc. + * Code generators are executed in the order in which they appear on the + * command line. + * + * If |insertion_point| is present, |name| must also be present. + * + * @generated from field: optional string insertion_point = 2; + */ + insertionPoint: string; + /** + * The file contents. + * + * @generated from field: optional string content = 15; + */ + content: string; + /** + * Information describing the file content being inserted. If an insertion + * point is used, this information will be appropriately offset and inserted + * into the code generation metadata for the generated files. + * + * @generated from field: optional google.protobuf.GeneratedCodeInfo generated_code_info = 16; + */ + generatedCodeInfo?: GeneratedCodeInfo; +}; +/** + * Represents a single generated file. + * + * @generated from message google.protobuf.compiler.CodeGeneratorResponse.File + */ +export type CodeGeneratorResponse_FileJson = { + /** + * The file name, relative to the output directory. The name must not + * contain "." or ".." components and must be relative, not be absolute (so, + * the file cannot lie outside the output directory). "/" must be used as + * the path separator, not "\". + * + * If the name is omitted, the content will be appended to the previous + * file. This allows the generator to break large files into small chunks, + * and allows the generated text to be streamed back to protoc so that large + * files need not reside completely in memory at one time. Note that as of + * this writing protoc does not optimize for this -- it will read the entire + * CodeGeneratorResponse before writing files to disk. + * + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * If non-empty, indicates that the named file should already exist, and the + * content here is to be inserted into that file at a defined insertion + * point. This feature allows a code generator to extend the output + * produced by another code generator. The original generator may provide + * insertion points by placing special annotations in the file that look + * like: + * @@protoc_insertion_point(NAME) + * The annotation can have arbitrary text before and after it on the line, + * which allows it to be placed in a comment. NAME should be replaced with + * an identifier naming the point -- this is what other generators will use + * as the insertion_point. Code inserted at this point will be placed + * immediately above the line containing the insertion point (thus multiple + * insertions to the same point will come out in the order they were added). + * The double-@ is intended to make it unlikely that the generated code + * could contain things that look like insertion points by accident. + * + * For example, the C++ code generator places the following line in the + * .pb.h files that it generates: + * // @@protoc_insertion_point(namespace_scope) + * This line appears within the scope of the file's package namespace, but + * outside of any particular class. Another plugin can then specify the + * insertion_point "namespace_scope" to generate additional classes or + * other declarations that should be placed in this scope. + * + * Note that if the line containing the insertion point begins with + * whitespace, the same whitespace will be added to every line of the + * inserted text. This is useful for languages like Python, where + * indentation matters. In these languages, the insertion point comment + * should be indented the same amount as any inserted code will need to be + * in order to work correctly in that context. + * + * The code generator that generates the initial file and the one which + * inserts into it must both run as part of a single invocation of protoc. + * Code generators are executed in the order in which they appear on the + * command line. + * + * If |insertion_point| is present, |name| must also be present. + * + * @generated from field: optional string insertion_point = 2; + */ + insertionPoint?: string; + /** + * The file contents. + * + * @generated from field: optional string content = 15; + */ + content?: string; + /** + * Information describing the file content being inserted. If an insertion + * point is used, this information will be appropriately offset and inserted + * into the code generation metadata for the generated files. + * + * @generated from field: optional google.protobuf.GeneratedCodeInfo generated_code_info = 16; + */ + generatedCodeInfo?: GeneratedCodeInfoJson; +}; +/** + * Describes the message google.protobuf.compiler.CodeGeneratorResponse.File. + * Use `create(CodeGeneratorResponse_FileSchema)` to create a new message. + */ +export declare const CodeGeneratorResponse_FileSchema: GenMessage; +/** + * Sync with code_generator.h. + * + * @generated from enum google.protobuf.compiler.CodeGeneratorResponse.Feature + */ +export declare enum CodeGeneratorResponse_Feature { + /** + * @generated from enum value: FEATURE_NONE = 0; + */ + NONE = 0, + /** + * @generated from enum value: FEATURE_PROTO3_OPTIONAL = 1; + */ + PROTO3_OPTIONAL = 1, + /** + * @generated from enum value: FEATURE_SUPPORTS_EDITIONS = 2; + */ + SUPPORTS_EDITIONS = 2 +} +/** + * Sync with code_generator.h. + * + * @generated from enum google.protobuf.compiler.CodeGeneratorResponse.Feature + */ +export type CodeGeneratorResponse_FeatureJson = "FEATURE_NONE" | "FEATURE_PROTO3_OPTIONAL" | "FEATURE_SUPPORTS_EDITIONS"; +/** + * Describes the enum google.protobuf.compiler.CodeGeneratorResponse.Feature. + */ +export declare const CodeGeneratorResponse_FeatureSchema: GenEnum; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/compiler/plugin_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/compiler/plugin_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..05fe4a3321ac79200dd9bae5726a6c20337c7176 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/compiler/plugin_pb.js @@ -0,0 +1,68 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.CodeGeneratorResponse_FeatureSchema = exports.CodeGeneratorResponse_Feature = exports.CodeGeneratorResponse_FileSchema = exports.CodeGeneratorResponseSchema = exports.CodeGeneratorRequestSchema = exports.VersionSchema = exports.file_google_protobuf_compiler_plugin = void 0; +const file_js_1 = require("../../../../../codegenv2/file.js"); +const descriptor_pb_js_1 = require("../descriptor_pb.js"); +const message_js_1 = require("../../../../../codegenv2/message.js"); +const enum_js_1 = require("../../../../../codegenv2/enum.js"); +/** + * Describes the file google/protobuf/compiler/plugin.proto. + */ +exports.file_google_protobuf_compiler_plugin = (0, file_js_1.fileDesc)("CiVnb29nbGUvcHJvdG9idWYvY29tcGlsZXIvcGx1Z2luLnByb3RvEhhnb29nbGUucHJvdG9idWYuY29tcGlsZXIiRgoHVmVyc2lvbhINCgVtYWpvchgBIAEoBRINCgVtaW5vchgCIAEoBRINCgVwYXRjaBgDIAEoBRIOCgZzdWZmaXgYBCABKAkigQIKFENvZGVHZW5lcmF0b3JSZXF1ZXN0EhgKEGZpbGVfdG9fZ2VuZXJhdGUYASADKAkSEQoJcGFyYW1ldGVyGAIgASgJEjgKCnByb3RvX2ZpbGUYDyADKAsyJC5nb29nbGUucHJvdG9idWYuRmlsZURlc2NyaXB0b3JQcm90bxJFChdzb3VyY2VfZmlsZV9kZXNjcmlwdG9ycxgRIAMoCzIkLmdvb2dsZS5wcm90b2J1Zi5GaWxlRGVzY3JpcHRvclByb3RvEjsKEGNvbXBpbGVyX3ZlcnNpb24YAyABKAsyIS5nb29nbGUucHJvdG9idWYuY29tcGlsZXIuVmVyc2lvbiKSAwoVQ29kZUdlbmVyYXRvclJlc3BvbnNlEg0KBWVycm9yGAEgASgJEhoKEnN1cHBvcnRlZF9mZWF0dXJlcxgCIAEoBBIXCg9taW5pbXVtX2VkaXRpb24YAyABKAUSFwoPbWF4aW11bV9lZGl0aW9uGAQgASgFEkIKBGZpbGUYDyADKAsyNC5nb29nbGUucHJvdG9idWYuY29tcGlsZXIuQ29kZUdlbmVyYXRvclJlc3BvbnNlLkZpbGUafwoERmlsZRIMCgRuYW1lGAEgASgJEhcKD2luc2VydGlvbl9wb2ludBgCIAEoCRIPCgdjb250ZW50GA8gASgJEj8KE2dlbmVyYXRlZF9jb2RlX2luZm8YECABKAsyIi5nb29nbGUucHJvdG9idWYuR2VuZXJhdGVkQ29kZUluZm8iVwoHRmVhdHVyZRIQCgxGRUFUVVJFX05PTkUQABIbChdGRUFUVVJFX1BST1RPM19PUFRJT05BTBABEh0KGUZFQVRVUkVfU1VQUE9SVFNfRURJVElPTlMQAkJyChxjb20uZ29vZ2xlLnByb3RvYnVmLmNvbXBpbGVyQgxQbHVnaW5Qcm90b3NaKWdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL3BsdWdpbnBiqgIYR29vZ2xlLlByb3RvYnVmLkNvbXBpbGVy", [descriptor_pb_js_1.file_google_protobuf_descriptor]); +/** + * Describes the message google.protobuf.compiler.Version. + * Use `create(VersionSchema)` to create a new message. + */ +exports.VersionSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_compiler_plugin, 0); +/** + * Describes the message google.protobuf.compiler.CodeGeneratorRequest. + * Use `create(CodeGeneratorRequestSchema)` to create a new message. + */ +exports.CodeGeneratorRequestSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_compiler_plugin, 1); +/** + * Describes the message google.protobuf.compiler.CodeGeneratorResponse. + * Use `create(CodeGeneratorResponseSchema)` to create a new message. + */ +exports.CodeGeneratorResponseSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_compiler_plugin, 2); +/** + * Describes the message google.protobuf.compiler.CodeGeneratorResponse.File. + * Use `create(CodeGeneratorResponse_FileSchema)` to create a new message. + */ +exports.CodeGeneratorResponse_FileSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_compiler_plugin, 2, 0); +/** + * Sync with code_generator.h. + * + * @generated from enum google.protobuf.compiler.CodeGeneratorResponse.Feature + */ +var CodeGeneratorResponse_Feature; +(function (CodeGeneratorResponse_Feature) { + /** + * @generated from enum value: FEATURE_NONE = 0; + */ + CodeGeneratorResponse_Feature[CodeGeneratorResponse_Feature["NONE"] = 0] = "NONE"; + /** + * @generated from enum value: FEATURE_PROTO3_OPTIONAL = 1; + */ + CodeGeneratorResponse_Feature[CodeGeneratorResponse_Feature["PROTO3_OPTIONAL"] = 1] = "PROTO3_OPTIONAL"; + /** + * @generated from enum value: FEATURE_SUPPORTS_EDITIONS = 2; + */ + CodeGeneratorResponse_Feature[CodeGeneratorResponse_Feature["SUPPORTS_EDITIONS"] = 2] = "SUPPORTS_EDITIONS"; +})(CodeGeneratorResponse_Feature || (exports.CodeGeneratorResponse_Feature = CodeGeneratorResponse_Feature = {})); +/** + * Describes the enum google.protobuf.compiler.CodeGeneratorResponse.Feature. + */ +exports.CodeGeneratorResponse_FeatureSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_compiler_plugin, 2, 0); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/cpp_features_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/cpp_features_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7da3c6db13d89af5b54049f3c79eb59cfb442d35 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/cpp_features_pb.d.ts @@ -0,0 +1,91 @@ +import type { GenEnum, GenExtension, GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { FeatureSet } from "./descriptor_pb.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/cpp_features.proto. + */ +export declare const file_google_protobuf_cpp_features: GenFile; +/** + * @generated from message pb.CppFeatures + */ +export type CppFeatures = Message<"pb.CppFeatures"> & { + /** + * Whether or not to treat an enum field as closed. This option is only + * applicable to enum fields, and will be removed in the future. It is + * consistent with the legacy behavior of using proto3 enum types for proto2 + * fields. + * + * @generated from field: optional bool legacy_closed_enum = 1; + */ + legacyClosedEnum: boolean; + /** + * @generated from field: optional pb.CppFeatures.StringType string_type = 2; + */ + stringType: CppFeatures_StringType; + /** + * @generated from field: optional bool enum_name_uses_string_view = 3; + */ + enumNameUsesStringView: boolean; +}; +/** + * @generated from message pb.CppFeatures + */ +export type CppFeaturesJson = { + /** + * Whether or not to treat an enum field as closed. This option is only + * applicable to enum fields, and will be removed in the future. It is + * consistent with the legacy behavior of using proto3 enum types for proto2 + * fields. + * + * @generated from field: optional bool legacy_closed_enum = 1; + */ + legacyClosedEnum?: boolean; + /** + * @generated from field: optional pb.CppFeatures.StringType string_type = 2; + */ + stringType?: CppFeatures_StringTypeJson; + /** + * @generated from field: optional bool enum_name_uses_string_view = 3; + */ + enumNameUsesStringView?: boolean; +}; +/** + * Describes the message pb.CppFeatures. + * Use `create(CppFeaturesSchema)` to create a new message. + */ +export declare const CppFeaturesSchema: GenMessage; +/** + * @generated from enum pb.CppFeatures.StringType + */ +export declare enum CppFeatures_StringType { + /** + * @generated from enum value: STRING_TYPE_UNKNOWN = 0; + */ + STRING_TYPE_UNKNOWN = 0, + /** + * @generated from enum value: VIEW = 1; + */ + VIEW = 1, + /** + * @generated from enum value: CORD = 2; + */ + CORD = 2, + /** + * @generated from enum value: STRING = 3; + */ + STRING = 3 +} +/** + * @generated from enum pb.CppFeatures.StringType + */ +export type CppFeatures_StringTypeJson = "STRING_TYPE_UNKNOWN" | "VIEW" | "CORD" | "STRING"; +/** + * Describes the enum pb.CppFeatures.StringType. + */ +export declare const CppFeatures_StringTypeSchema: GenEnum; +/** + * @generated from extension: optional pb.CppFeatures cpp = 1000; + */ +export declare const cpp: GenExtension; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/cpp_features_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/cpp_features_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..80852de84d11ff62e492533300be2b668cee8961 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/cpp_features_pb.js @@ -0,0 +1,60 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.cpp = exports.CppFeatures_StringTypeSchema = exports.CppFeatures_StringType = exports.CppFeaturesSchema = exports.file_google_protobuf_cpp_features = void 0; +const file_js_1 = require("../../../../codegenv2/file.js"); +const descriptor_pb_js_1 = require("./descriptor_pb.js"); +const message_js_1 = require("../../../../codegenv2/message.js"); +const enum_js_1 = require("../../../../codegenv2/enum.js"); +const extension_js_1 = require("../../../../codegenv2/extension.js"); +/** + * Describes the file google/protobuf/cpp_features.proto. + */ +exports.file_google_protobuf_cpp_features = (0, file_js_1.fileDesc)("CiJnb29nbGUvcHJvdG9idWYvY3BwX2ZlYXR1cmVzLnByb3RvEgJwYiL8AwoLQ3BwRmVhdHVyZXMS+wEKEmxlZ2FjeV9jbG9zZWRfZW51bRgBIAEoCELeAYgBAZgBBJgBAaIBCRIEdHJ1ZRiEB6IBChIFZmFsc2UY5weyAbgBCOgHEOgHGq8BVGhlIGxlZ2FjeSBjbG9zZWQgZW51bSBiZWhhdmlvciBpbiBDKysgaXMgZGVwcmVjYXRlZCBhbmQgaXMgc2NoZWR1bGVkIHRvIGJlIHJlbW92ZWQgaW4gZWRpdGlvbiAyMDI1LiAgU2VlIGh0dHA6Ly9wcm90b2J1Zi5kZXYvcHJvZ3JhbW1pbmctZ3VpZGVzL2VudW0vI2NwcCBmb3IgbW9yZSBpbmZvcm1hdGlvbhJaCgtzdHJpbmdfdHlwZRgCIAEoDjIaLnBiLkNwcEZlYXR1cmVzLlN0cmluZ1R5cGVCKYgBAZgBBJgBAaIBCxIGU1RSSU5HGIQHogEJEgRWSUVXGOkHsgEDCOgHEkwKGmVudW1fbmFtZV91c2VzX3N0cmluZ192aWV3GAMgASgIQiiIAQKYAQaYAQGiAQoSBWZhbHNlGIQHogEJEgR0cnVlGOkHsgEDCOkHIkUKClN0cmluZ1R5cGUSFwoTU1RSSU5HX1RZUEVfVU5LTk9XThAAEggKBFZJRVcQARIICgRDT1JEEAISCgoGU1RSSU5HEAM6PwoDY3BwEhsuZ29vZ2xlLnByb3RvYnVmLkZlYXR1cmVTZXQY6AcgASgLMg8ucGIuQ3BwRmVhdHVyZXNSA2NwcA", [descriptor_pb_js_1.file_google_protobuf_descriptor]); +/** + * Describes the message pb.CppFeatures. + * Use `create(CppFeaturesSchema)` to create a new message. + */ +exports.CppFeaturesSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_cpp_features, 0); +/** + * @generated from enum pb.CppFeatures.StringType + */ +var CppFeatures_StringType; +(function (CppFeatures_StringType) { + /** + * @generated from enum value: STRING_TYPE_UNKNOWN = 0; + */ + CppFeatures_StringType[CppFeatures_StringType["STRING_TYPE_UNKNOWN"] = 0] = "STRING_TYPE_UNKNOWN"; + /** + * @generated from enum value: VIEW = 1; + */ + CppFeatures_StringType[CppFeatures_StringType["VIEW"] = 1] = "VIEW"; + /** + * @generated from enum value: CORD = 2; + */ + CppFeatures_StringType[CppFeatures_StringType["CORD"] = 2] = "CORD"; + /** + * @generated from enum value: STRING = 3; + */ + CppFeatures_StringType[CppFeatures_StringType["STRING"] = 3] = "STRING"; +})(CppFeatures_StringType || (exports.CppFeatures_StringType = CppFeatures_StringType = {})); +/** + * Describes the enum pb.CppFeatures.StringType. + */ +exports.CppFeatures_StringTypeSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_cpp_features, 0, 0); +/** + * @generated from extension: optional pb.CppFeatures cpp = 1000; + */ +exports.cpp = (0, extension_js_1.extDesc)(exports.file_google_protobuf_cpp_features, 0); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/descriptor_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/descriptor_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e40bcfced58785ce6c6b2bfdf4e99c62d483d18e --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/descriptor_pb.d.ts @@ -0,0 +1,4119 @@ +import type { GenEnum, GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/descriptor.proto. + */ +export declare const file_google_protobuf_descriptor: GenFile; +/** + * The protocol compiler can output a FileDescriptorSet containing the .proto + * files it parses. + * + * @generated from message google.protobuf.FileDescriptorSet + */ +export type FileDescriptorSet = Message<"google.protobuf.FileDescriptorSet"> & { + /** + * @generated from field: repeated google.protobuf.FileDescriptorProto file = 1; + */ + file: FileDescriptorProto[]; +}; +/** + * The protocol compiler can output a FileDescriptorSet containing the .proto + * files it parses. + * + * @generated from message google.protobuf.FileDescriptorSet + */ +export type FileDescriptorSetJson = { + /** + * @generated from field: repeated google.protobuf.FileDescriptorProto file = 1; + */ + file?: FileDescriptorProtoJson[]; +}; +/** + * Describes the message google.protobuf.FileDescriptorSet. + * Use `create(FileDescriptorSetSchema)` to create a new message. + */ +export declare const FileDescriptorSetSchema: GenMessage; +/** + * Describes a complete .proto file. + * + * @generated from message google.protobuf.FileDescriptorProto + */ +export type FileDescriptorProto = Message<"google.protobuf.FileDescriptorProto"> & { + /** + * file name, relative to root of source tree + * + * @generated from field: optional string name = 1; + */ + name: string; + /** + * e.g. "foo", "foo.bar", etc. + * + * @generated from field: optional string package = 2; + */ + package: string; + /** + * Names of files imported by this file. + * + * @generated from field: repeated string dependency = 3; + */ + dependency: string[]; + /** + * Indexes of the public imported files in the dependency list above. + * + * @generated from field: repeated int32 public_dependency = 10; + */ + publicDependency: number[]; + /** + * Indexes of the weak imported files in the dependency list. + * For Google-internal migration only. Do not use. + * + * @generated from field: repeated int32 weak_dependency = 11; + */ + weakDependency: number[]; + /** + * Names of files imported by this file purely for the purpose of providing + * option extensions. These are excluded from the dependency list above. + * + * @generated from field: repeated string option_dependency = 15; + */ + optionDependency: string[]; + /** + * All top-level definitions in this file. + * + * @generated from field: repeated google.protobuf.DescriptorProto message_type = 4; + */ + messageType: DescriptorProto[]; + /** + * @generated from field: repeated google.protobuf.EnumDescriptorProto enum_type = 5; + */ + enumType: EnumDescriptorProto[]; + /** + * @generated from field: repeated google.protobuf.ServiceDescriptorProto service = 6; + */ + service: ServiceDescriptorProto[]; + /** + * @generated from field: repeated google.protobuf.FieldDescriptorProto extension = 7; + */ + extension: FieldDescriptorProto[]; + /** + * @generated from field: optional google.protobuf.FileOptions options = 8; + */ + options?: FileOptions; + /** + * This field contains optional information about the original source code. + * You may safely remove this entire field without harming runtime + * functionality of the descriptors -- the information is needed only by + * development tools. + * + * @generated from field: optional google.protobuf.SourceCodeInfo source_code_info = 9; + */ + sourceCodeInfo?: SourceCodeInfo; + /** + * The syntax of the proto file. + * The supported values are "proto2", "proto3", and "editions". + * + * If `edition` is present, this value must be "editions". + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional string syntax = 12; + */ + syntax: string; + /** + * The edition of the proto file. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.Edition edition = 14; + */ + edition: Edition; +}; +/** + * Describes a complete .proto file. + * + * @generated from message google.protobuf.FileDescriptorProto + */ +export type FileDescriptorProtoJson = { + /** + * file name, relative to root of source tree + * + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * e.g. "foo", "foo.bar", etc. + * + * @generated from field: optional string package = 2; + */ + package?: string; + /** + * Names of files imported by this file. + * + * @generated from field: repeated string dependency = 3; + */ + dependency?: string[]; + /** + * Indexes of the public imported files in the dependency list above. + * + * @generated from field: repeated int32 public_dependency = 10; + */ + publicDependency?: number[]; + /** + * Indexes of the weak imported files in the dependency list. + * For Google-internal migration only. Do not use. + * + * @generated from field: repeated int32 weak_dependency = 11; + */ + weakDependency?: number[]; + /** + * Names of files imported by this file purely for the purpose of providing + * option extensions. These are excluded from the dependency list above. + * + * @generated from field: repeated string option_dependency = 15; + */ + optionDependency?: string[]; + /** + * All top-level definitions in this file. + * + * @generated from field: repeated google.protobuf.DescriptorProto message_type = 4; + */ + messageType?: DescriptorProtoJson[]; + /** + * @generated from field: repeated google.protobuf.EnumDescriptorProto enum_type = 5; + */ + enumType?: EnumDescriptorProtoJson[]; + /** + * @generated from field: repeated google.protobuf.ServiceDescriptorProto service = 6; + */ + service?: ServiceDescriptorProtoJson[]; + /** + * @generated from field: repeated google.protobuf.FieldDescriptorProto extension = 7; + */ + extension?: FieldDescriptorProtoJson[]; + /** + * @generated from field: optional google.protobuf.FileOptions options = 8; + */ + options?: FileOptionsJson; + /** + * This field contains optional information about the original source code. + * You may safely remove this entire field without harming runtime + * functionality of the descriptors -- the information is needed only by + * development tools. + * + * @generated from field: optional google.protobuf.SourceCodeInfo source_code_info = 9; + */ + sourceCodeInfo?: SourceCodeInfoJson; + /** + * The syntax of the proto file. + * The supported values are "proto2", "proto3", and "editions". + * + * If `edition` is present, this value must be "editions". + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional string syntax = 12; + */ + syntax?: string; + /** + * The edition of the proto file. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.Edition edition = 14; + */ + edition?: EditionJson; +}; +/** + * Describes the message google.protobuf.FileDescriptorProto. + * Use `create(FileDescriptorProtoSchema)` to create a new message. + */ +export declare const FileDescriptorProtoSchema: GenMessage; +/** + * Describes a message type. + * + * @generated from message google.protobuf.DescriptorProto + */ +export type DescriptorProto = Message<"google.protobuf.DescriptorProto"> & { + /** + * @generated from field: optional string name = 1; + */ + name: string; + /** + * @generated from field: repeated google.protobuf.FieldDescriptorProto field = 2; + */ + field: FieldDescriptorProto[]; + /** + * @generated from field: repeated google.protobuf.FieldDescriptorProto extension = 6; + */ + extension: FieldDescriptorProto[]; + /** + * @generated from field: repeated google.protobuf.DescriptorProto nested_type = 3; + */ + nestedType: DescriptorProto[]; + /** + * @generated from field: repeated google.protobuf.EnumDescriptorProto enum_type = 4; + */ + enumType: EnumDescriptorProto[]; + /** + * @generated from field: repeated google.protobuf.DescriptorProto.ExtensionRange extension_range = 5; + */ + extensionRange: DescriptorProto_ExtensionRange[]; + /** + * @generated from field: repeated google.protobuf.OneofDescriptorProto oneof_decl = 8; + */ + oneofDecl: OneofDescriptorProto[]; + /** + * @generated from field: optional google.protobuf.MessageOptions options = 7; + */ + options?: MessageOptions; + /** + * @generated from field: repeated google.protobuf.DescriptorProto.ReservedRange reserved_range = 9; + */ + reservedRange: DescriptorProto_ReservedRange[]; + /** + * Reserved field names, which may not be used by fields in the same message. + * A given name may only be reserved once. + * + * @generated from field: repeated string reserved_name = 10; + */ + reservedName: string[]; + /** + * Support for `export` and `local` keywords on enums. + * + * @generated from field: optional google.protobuf.SymbolVisibility visibility = 11; + */ + visibility: SymbolVisibility; +}; +/** + * Describes a message type. + * + * @generated from message google.protobuf.DescriptorProto + */ +export type DescriptorProtoJson = { + /** + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * @generated from field: repeated google.protobuf.FieldDescriptorProto field = 2; + */ + field?: FieldDescriptorProtoJson[]; + /** + * @generated from field: repeated google.protobuf.FieldDescriptorProto extension = 6; + */ + extension?: FieldDescriptorProtoJson[]; + /** + * @generated from field: repeated google.protobuf.DescriptorProto nested_type = 3; + */ + nestedType?: DescriptorProtoJson[]; + /** + * @generated from field: repeated google.protobuf.EnumDescriptorProto enum_type = 4; + */ + enumType?: EnumDescriptorProtoJson[]; + /** + * @generated from field: repeated google.protobuf.DescriptorProto.ExtensionRange extension_range = 5; + */ + extensionRange?: DescriptorProto_ExtensionRangeJson[]; + /** + * @generated from field: repeated google.protobuf.OneofDescriptorProto oneof_decl = 8; + */ + oneofDecl?: OneofDescriptorProtoJson[]; + /** + * @generated from field: optional google.protobuf.MessageOptions options = 7; + */ + options?: MessageOptionsJson; + /** + * @generated from field: repeated google.protobuf.DescriptorProto.ReservedRange reserved_range = 9; + */ + reservedRange?: DescriptorProto_ReservedRangeJson[]; + /** + * Reserved field names, which may not be used by fields in the same message. + * A given name may only be reserved once. + * + * @generated from field: repeated string reserved_name = 10; + */ + reservedName?: string[]; + /** + * Support for `export` and `local` keywords on enums. + * + * @generated from field: optional google.protobuf.SymbolVisibility visibility = 11; + */ + visibility?: SymbolVisibilityJson; +}; +/** + * Describes the message google.protobuf.DescriptorProto. + * Use `create(DescriptorProtoSchema)` to create a new message. + */ +export declare const DescriptorProtoSchema: GenMessage; +/** + * @generated from message google.protobuf.DescriptorProto.ExtensionRange + */ +export type DescriptorProto_ExtensionRange = Message<"google.protobuf.DescriptorProto.ExtensionRange"> & { + /** + * Inclusive. + * + * @generated from field: optional int32 start = 1; + */ + start: number; + /** + * Exclusive. + * + * @generated from field: optional int32 end = 2; + */ + end: number; + /** + * @generated from field: optional google.protobuf.ExtensionRangeOptions options = 3; + */ + options?: ExtensionRangeOptions; +}; +/** + * @generated from message google.protobuf.DescriptorProto.ExtensionRange + */ +export type DescriptorProto_ExtensionRangeJson = { + /** + * Inclusive. + * + * @generated from field: optional int32 start = 1; + */ + start?: number; + /** + * Exclusive. + * + * @generated from field: optional int32 end = 2; + */ + end?: number; + /** + * @generated from field: optional google.protobuf.ExtensionRangeOptions options = 3; + */ + options?: ExtensionRangeOptionsJson; +}; +/** + * Describes the message google.protobuf.DescriptorProto.ExtensionRange. + * Use `create(DescriptorProto_ExtensionRangeSchema)` to create a new message. + */ +export declare const DescriptorProto_ExtensionRangeSchema: GenMessage; +/** + * Range of reserved tag numbers. Reserved tag numbers may not be used by + * fields or extension ranges in the same message. Reserved ranges may + * not overlap. + * + * @generated from message google.protobuf.DescriptorProto.ReservedRange + */ +export type DescriptorProto_ReservedRange = Message<"google.protobuf.DescriptorProto.ReservedRange"> & { + /** + * Inclusive. + * + * @generated from field: optional int32 start = 1; + */ + start: number; + /** + * Exclusive. + * + * @generated from field: optional int32 end = 2; + */ + end: number; +}; +/** + * Range of reserved tag numbers. Reserved tag numbers may not be used by + * fields or extension ranges in the same message. Reserved ranges may + * not overlap. + * + * @generated from message google.protobuf.DescriptorProto.ReservedRange + */ +export type DescriptorProto_ReservedRangeJson = { + /** + * Inclusive. + * + * @generated from field: optional int32 start = 1; + */ + start?: number; + /** + * Exclusive. + * + * @generated from field: optional int32 end = 2; + */ + end?: number; +}; +/** + * Describes the message google.protobuf.DescriptorProto.ReservedRange. + * Use `create(DescriptorProto_ReservedRangeSchema)` to create a new message. + */ +export declare const DescriptorProto_ReservedRangeSchema: GenMessage; +/** + * @generated from message google.protobuf.ExtensionRangeOptions + */ +export type ExtensionRangeOptions = Message<"google.protobuf.ExtensionRangeOptions"> & { + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; + /** + * For external users: DO NOT USE. We are in the process of open sourcing + * extension declaration and executing internal cleanups before it can be + * used externally. + * + * @generated from field: repeated google.protobuf.ExtensionRangeOptions.Declaration declaration = 2; + */ + declaration: ExtensionRangeOptions_Declaration[]; + /** + * Any features defined in the specific edition. + * + * @generated from field: optional google.protobuf.FeatureSet features = 50; + */ + features?: FeatureSet; + /** + * The verification state of the range. + * TODO: flip the default to DECLARATION once all empty ranges + * are marked as UNVERIFIED. + * + * @generated from field: optional google.protobuf.ExtensionRangeOptions.VerificationState verification = 3 [default = UNVERIFIED]; + */ + verification: ExtensionRangeOptions_VerificationState; +}; +/** + * @generated from message google.protobuf.ExtensionRangeOptions + */ +export type ExtensionRangeOptionsJson = { + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; + /** + * For external users: DO NOT USE. We are in the process of open sourcing + * extension declaration and executing internal cleanups before it can be + * used externally. + * + * @generated from field: repeated google.protobuf.ExtensionRangeOptions.Declaration declaration = 2; + */ + declaration?: ExtensionRangeOptions_DeclarationJson[]; + /** + * Any features defined in the specific edition. + * + * @generated from field: optional google.protobuf.FeatureSet features = 50; + */ + features?: FeatureSetJson; + /** + * The verification state of the range. + * TODO: flip the default to DECLARATION once all empty ranges + * are marked as UNVERIFIED. + * + * @generated from field: optional google.protobuf.ExtensionRangeOptions.VerificationState verification = 3 [default = UNVERIFIED]; + */ + verification?: ExtensionRangeOptions_VerificationStateJson; +}; +/** + * Describes the message google.protobuf.ExtensionRangeOptions. + * Use `create(ExtensionRangeOptionsSchema)` to create a new message. + */ +export declare const ExtensionRangeOptionsSchema: GenMessage; +/** + * @generated from message google.protobuf.ExtensionRangeOptions.Declaration + */ +export type ExtensionRangeOptions_Declaration = Message<"google.protobuf.ExtensionRangeOptions.Declaration"> & { + /** + * The extension number declared within the extension range. + * + * @generated from field: optional int32 number = 1; + */ + number: number; + /** + * The fully-qualified name of the extension field. There must be a leading + * dot in front of the full name. + * + * @generated from field: optional string full_name = 2; + */ + fullName: string; + /** + * The fully-qualified type name of the extension field. Unlike + * Metadata.type, Declaration.type must have a leading dot for messages + * and enums. + * + * @generated from field: optional string type = 3; + */ + type: string; + /** + * If true, indicates that the number is reserved in the extension range, + * and any extension field with the number will fail to compile. Set this + * when a declared extension field is deleted. + * + * @generated from field: optional bool reserved = 5; + */ + reserved: boolean; + /** + * If true, indicates that the extension must be defined as repeated. + * Otherwise the extension must be defined as optional. + * + * @generated from field: optional bool repeated = 6; + */ + repeated: boolean; +}; +/** + * @generated from message google.protobuf.ExtensionRangeOptions.Declaration + */ +export type ExtensionRangeOptions_DeclarationJson = { + /** + * The extension number declared within the extension range. + * + * @generated from field: optional int32 number = 1; + */ + number?: number; + /** + * The fully-qualified name of the extension field. There must be a leading + * dot in front of the full name. + * + * @generated from field: optional string full_name = 2; + */ + fullName?: string; + /** + * The fully-qualified type name of the extension field. Unlike + * Metadata.type, Declaration.type must have a leading dot for messages + * and enums. + * + * @generated from field: optional string type = 3; + */ + type?: string; + /** + * If true, indicates that the number is reserved in the extension range, + * and any extension field with the number will fail to compile. Set this + * when a declared extension field is deleted. + * + * @generated from field: optional bool reserved = 5; + */ + reserved?: boolean; + /** + * If true, indicates that the extension must be defined as repeated. + * Otherwise the extension must be defined as optional. + * + * @generated from field: optional bool repeated = 6; + */ + repeated?: boolean; +}; +/** + * Describes the message google.protobuf.ExtensionRangeOptions.Declaration. + * Use `create(ExtensionRangeOptions_DeclarationSchema)` to create a new message. + */ +export declare const ExtensionRangeOptions_DeclarationSchema: GenMessage; +/** + * The verification state of the extension range. + * + * @generated from enum google.protobuf.ExtensionRangeOptions.VerificationState + */ +export declare enum ExtensionRangeOptions_VerificationState { + /** + * All the extensions of the range must be declared. + * + * @generated from enum value: DECLARATION = 0; + */ + DECLARATION = 0, + /** + * @generated from enum value: UNVERIFIED = 1; + */ + UNVERIFIED = 1 +} +/** + * The verification state of the extension range. + * + * @generated from enum google.protobuf.ExtensionRangeOptions.VerificationState + */ +export type ExtensionRangeOptions_VerificationStateJson = "DECLARATION" | "UNVERIFIED"; +/** + * Describes the enum google.protobuf.ExtensionRangeOptions.VerificationState. + */ +export declare const ExtensionRangeOptions_VerificationStateSchema: GenEnum; +/** + * Describes a field within a message. + * + * @generated from message google.protobuf.FieldDescriptorProto + */ +export type FieldDescriptorProto = Message<"google.protobuf.FieldDescriptorProto"> & { + /** + * @generated from field: optional string name = 1; + */ + name: string; + /** + * @generated from field: optional int32 number = 3; + */ + number: number; + /** + * @generated from field: optional google.protobuf.FieldDescriptorProto.Label label = 4; + */ + label: FieldDescriptorProto_Label; + /** + * If type_name is set, this need not be set. If both this and type_name + * are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. + * + * @generated from field: optional google.protobuf.FieldDescriptorProto.Type type = 5; + */ + type: FieldDescriptorProto_Type; + /** + * For message and enum types, this is the name of the type. If the name + * starts with a '.', it is fully-qualified. Otherwise, C++-like scoping + * rules are used to find the type (i.e. first the nested types within this + * message are searched, then within the parent, on up to the root + * namespace). + * + * @generated from field: optional string type_name = 6; + */ + typeName: string; + /** + * For extensions, this is the name of the type being extended. It is + * resolved in the same manner as type_name. + * + * @generated from field: optional string extendee = 2; + */ + extendee: string; + /** + * For numeric types, contains the original text representation of the value. + * For booleans, "true" or "false". + * For strings, contains the default text contents (not escaped in any way). + * For bytes, contains the C escaped value. All bytes >= 128 are escaped. + * + * @generated from field: optional string default_value = 7; + */ + defaultValue: string; + /** + * If set, gives the index of a oneof in the containing type's oneof_decl + * list. This field is a member of that oneof. + * + * @generated from field: optional int32 oneof_index = 9; + */ + oneofIndex: number; + /** + * JSON name of this field. The value is set by protocol compiler. If the + * user has set a "json_name" option on this field, that option's value + * will be used. Otherwise, it's deduced from the field's name by converting + * it to camelCase. + * + * @generated from field: optional string json_name = 10; + */ + jsonName: string; + /** + * @generated from field: optional google.protobuf.FieldOptions options = 8; + */ + options?: FieldOptions; + /** + * If true, this is a proto3 "optional". When a proto3 field is optional, it + * tracks presence regardless of field type. + * + * When proto3_optional is true, this field must belong to a oneof to signal + * to old proto3 clients that presence is tracked for this field. This oneof + * is known as a "synthetic" oneof, and this field must be its sole member + * (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs + * exist in the descriptor only, and do not generate any API. Synthetic oneofs + * must be ordered after all "real" oneofs. + * + * For message fields, proto3_optional doesn't create any semantic change, + * since non-repeated message fields always track presence. However it still + * indicates the semantic detail of whether the user wrote "optional" or not. + * This can be useful for round-tripping the .proto file. For consistency we + * give message fields a synthetic oneof also, even though it is not required + * to track presence. This is especially important because the parser can't + * tell if a field is a message or an enum, so it must always create a + * synthetic oneof. + * + * Proto2 optional fields do not set this flag, because they already indicate + * optional with `LABEL_OPTIONAL`. + * + * @generated from field: optional bool proto3_optional = 17; + */ + proto3Optional: boolean; +}; +/** + * Describes a field within a message. + * + * @generated from message google.protobuf.FieldDescriptorProto + */ +export type FieldDescriptorProtoJson = { + /** + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * @generated from field: optional int32 number = 3; + */ + number?: number; + /** + * @generated from field: optional google.protobuf.FieldDescriptorProto.Label label = 4; + */ + label?: FieldDescriptorProto_LabelJson; + /** + * If type_name is set, this need not be set. If both this and type_name + * are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. + * + * @generated from field: optional google.protobuf.FieldDescriptorProto.Type type = 5; + */ + type?: FieldDescriptorProto_TypeJson; + /** + * For message and enum types, this is the name of the type. If the name + * starts with a '.', it is fully-qualified. Otherwise, C++-like scoping + * rules are used to find the type (i.e. first the nested types within this + * message are searched, then within the parent, on up to the root + * namespace). + * + * @generated from field: optional string type_name = 6; + */ + typeName?: string; + /** + * For extensions, this is the name of the type being extended. It is + * resolved in the same manner as type_name. + * + * @generated from field: optional string extendee = 2; + */ + extendee?: string; + /** + * For numeric types, contains the original text representation of the value. + * For booleans, "true" or "false". + * For strings, contains the default text contents (not escaped in any way). + * For bytes, contains the C escaped value. All bytes >= 128 are escaped. + * + * @generated from field: optional string default_value = 7; + */ + defaultValue?: string; + /** + * If set, gives the index of a oneof in the containing type's oneof_decl + * list. This field is a member of that oneof. + * + * @generated from field: optional int32 oneof_index = 9; + */ + oneofIndex?: number; + /** + * JSON name of this field. The value is set by protocol compiler. If the + * user has set a "json_name" option on this field, that option's value + * will be used. Otherwise, it's deduced from the field's name by converting + * it to camelCase. + * + * @generated from field: optional string json_name = 10; + */ + jsonName?: string; + /** + * @generated from field: optional google.protobuf.FieldOptions options = 8; + */ + options?: FieldOptionsJson; + /** + * If true, this is a proto3 "optional". When a proto3 field is optional, it + * tracks presence regardless of field type. + * + * When proto3_optional is true, this field must belong to a oneof to signal + * to old proto3 clients that presence is tracked for this field. This oneof + * is known as a "synthetic" oneof, and this field must be its sole member + * (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs + * exist in the descriptor only, and do not generate any API. Synthetic oneofs + * must be ordered after all "real" oneofs. + * + * For message fields, proto3_optional doesn't create any semantic change, + * since non-repeated message fields always track presence. However it still + * indicates the semantic detail of whether the user wrote "optional" or not. + * This can be useful for round-tripping the .proto file. For consistency we + * give message fields a synthetic oneof also, even though it is not required + * to track presence. This is especially important because the parser can't + * tell if a field is a message or an enum, so it must always create a + * synthetic oneof. + * + * Proto2 optional fields do not set this flag, because they already indicate + * optional with `LABEL_OPTIONAL`. + * + * @generated from field: optional bool proto3_optional = 17; + */ + proto3Optional?: boolean; +}; +/** + * Describes the message google.protobuf.FieldDescriptorProto. + * Use `create(FieldDescriptorProtoSchema)` to create a new message. + */ +export declare const FieldDescriptorProtoSchema: GenMessage; +/** + * @generated from enum google.protobuf.FieldDescriptorProto.Type + */ +export declare enum FieldDescriptorProto_Type { + /** + * 0 is reserved for errors. + * Order is weird for historical reasons. + * + * @generated from enum value: TYPE_DOUBLE = 1; + */ + DOUBLE = 1, + /** + * @generated from enum value: TYPE_FLOAT = 2; + */ + FLOAT = 2, + /** + * Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + * negative values are likely. + * + * @generated from enum value: TYPE_INT64 = 3; + */ + INT64 = 3, + /** + * @generated from enum value: TYPE_UINT64 = 4; + */ + UINT64 = 4, + /** + * Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + * negative values are likely. + * + * @generated from enum value: TYPE_INT32 = 5; + */ + INT32 = 5, + /** + * @generated from enum value: TYPE_FIXED64 = 6; + */ + FIXED64 = 6, + /** + * @generated from enum value: TYPE_FIXED32 = 7; + */ + FIXED32 = 7, + /** + * @generated from enum value: TYPE_BOOL = 8; + */ + BOOL = 8, + /** + * @generated from enum value: TYPE_STRING = 9; + */ + STRING = 9, + /** + * Tag-delimited aggregate. + * Group type is deprecated and not supported after google.protobuf. However, Proto3 + * implementations should still be able to parse the group wire format and + * treat group fields as unknown fields. In Editions, the group wire format + * can be enabled via the `message_encoding` feature. + * + * @generated from enum value: TYPE_GROUP = 10; + */ + GROUP = 10, + /** + * Length-delimited aggregate. + * + * @generated from enum value: TYPE_MESSAGE = 11; + */ + MESSAGE = 11, + /** + * New in version 2. + * + * @generated from enum value: TYPE_BYTES = 12; + */ + BYTES = 12, + /** + * @generated from enum value: TYPE_UINT32 = 13; + */ + UINT32 = 13, + /** + * @generated from enum value: TYPE_ENUM = 14; + */ + ENUM = 14, + /** + * @generated from enum value: TYPE_SFIXED32 = 15; + */ + SFIXED32 = 15, + /** + * @generated from enum value: TYPE_SFIXED64 = 16; + */ + SFIXED64 = 16, + /** + * Uses ZigZag encoding. + * + * @generated from enum value: TYPE_SINT32 = 17; + */ + SINT32 = 17, + /** + * Uses ZigZag encoding. + * + * @generated from enum value: TYPE_SINT64 = 18; + */ + SINT64 = 18 +} +/** + * @generated from enum google.protobuf.FieldDescriptorProto.Type + */ +export type FieldDescriptorProto_TypeJson = "TYPE_DOUBLE" | "TYPE_FLOAT" | "TYPE_INT64" | "TYPE_UINT64" | "TYPE_INT32" | "TYPE_FIXED64" | "TYPE_FIXED32" | "TYPE_BOOL" | "TYPE_STRING" | "TYPE_GROUP" | "TYPE_MESSAGE" | "TYPE_BYTES" | "TYPE_UINT32" | "TYPE_ENUM" | "TYPE_SFIXED32" | "TYPE_SFIXED64" | "TYPE_SINT32" | "TYPE_SINT64"; +/** + * Describes the enum google.protobuf.FieldDescriptorProto.Type. + */ +export declare const FieldDescriptorProto_TypeSchema: GenEnum; +/** + * @generated from enum google.protobuf.FieldDescriptorProto.Label + */ +export declare enum FieldDescriptorProto_Label { + /** + * 0 is reserved for errors + * + * @generated from enum value: LABEL_OPTIONAL = 1; + */ + OPTIONAL = 1, + /** + * @generated from enum value: LABEL_REPEATED = 3; + */ + REPEATED = 3, + /** + * The required label is only allowed in google.protobuf. In proto3 and Editions + * it's explicitly prohibited. In Editions, the `field_presence` feature + * can be used to get this behavior. + * + * @generated from enum value: LABEL_REQUIRED = 2; + */ + REQUIRED = 2 +} +/** + * @generated from enum google.protobuf.FieldDescriptorProto.Label + */ +export type FieldDescriptorProto_LabelJson = "LABEL_OPTIONAL" | "LABEL_REPEATED" | "LABEL_REQUIRED"; +/** + * Describes the enum google.protobuf.FieldDescriptorProto.Label. + */ +export declare const FieldDescriptorProto_LabelSchema: GenEnum; +/** + * Describes a oneof. + * + * @generated from message google.protobuf.OneofDescriptorProto + */ +export type OneofDescriptorProto = Message<"google.protobuf.OneofDescriptorProto"> & { + /** + * @generated from field: optional string name = 1; + */ + name: string; + /** + * @generated from field: optional google.protobuf.OneofOptions options = 2; + */ + options?: OneofOptions; +}; +/** + * Describes a oneof. + * + * @generated from message google.protobuf.OneofDescriptorProto + */ +export type OneofDescriptorProtoJson = { + /** + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * @generated from field: optional google.protobuf.OneofOptions options = 2; + */ + options?: OneofOptionsJson; +}; +/** + * Describes the message google.protobuf.OneofDescriptorProto. + * Use `create(OneofDescriptorProtoSchema)` to create a new message. + */ +export declare const OneofDescriptorProtoSchema: GenMessage; +/** + * Describes an enum type. + * + * @generated from message google.protobuf.EnumDescriptorProto + */ +export type EnumDescriptorProto = Message<"google.protobuf.EnumDescriptorProto"> & { + /** + * @generated from field: optional string name = 1; + */ + name: string; + /** + * @generated from field: repeated google.protobuf.EnumValueDescriptorProto value = 2; + */ + value: EnumValueDescriptorProto[]; + /** + * @generated from field: optional google.protobuf.EnumOptions options = 3; + */ + options?: EnumOptions; + /** + * Range of reserved numeric values. Reserved numeric values may not be used + * by enum values in the same enum declaration. Reserved ranges may not + * overlap. + * + * @generated from field: repeated google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4; + */ + reservedRange: EnumDescriptorProto_EnumReservedRange[]; + /** + * Reserved enum value names, which may not be reused. A given name may only + * be reserved once. + * + * @generated from field: repeated string reserved_name = 5; + */ + reservedName: string[]; + /** + * Support for `export` and `local` keywords on enums. + * + * @generated from field: optional google.protobuf.SymbolVisibility visibility = 6; + */ + visibility: SymbolVisibility; +}; +/** + * Describes an enum type. + * + * @generated from message google.protobuf.EnumDescriptorProto + */ +export type EnumDescriptorProtoJson = { + /** + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * @generated from field: repeated google.protobuf.EnumValueDescriptorProto value = 2; + */ + value?: EnumValueDescriptorProtoJson[]; + /** + * @generated from field: optional google.protobuf.EnumOptions options = 3; + */ + options?: EnumOptionsJson; + /** + * Range of reserved numeric values. Reserved numeric values may not be used + * by enum values in the same enum declaration. Reserved ranges may not + * overlap. + * + * @generated from field: repeated google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4; + */ + reservedRange?: EnumDescriptorProto_EnumReservedRangeJson[]; + /** + * Reserved enum value names, which may not be reused. A given name may only + * be reserved once. + * + * @generated from field: repeated string reserved_name = 5; + */ + reservedName?: string[]; + /** + * Support for `export` and `local` keywords on enums. + * + * @generated from field: optional google.protobuf.SymbolVisibility visibility = 6; + */ + visibility?: SymbolVisibilityJson; +}; +/** + * Describes the message google.protobuf.EnumDescriptorProto. + * Use `create(EnumDescriptorProtoSchema)` to create a new message. + */ +export declare const EnumDescriptorProtoSchema: GenMessage; +/** + * Range of reserved numeric values. Reserved values may not be used by + * entries in the same enum. Reserved ranges may not overlap. + * + * Note that this is distinct from DescriptorProto.ReservedRange in that it + * is inclusive such that it can appropriately represent the entire int32 + * domain. + * + * @generated from message google.protobuf.EnumDescriptorProto.EnumReservedRange + */ +export type EnumDescriptorProto_EnumReservedRange = Message<"google.protobuf.EnumDescriptorProto.EnumReservedRange"> & { + /** + * Inclusive. + * + * @generated from field: optional int32 start = 1; + */ + start: number; + /** + * Inclusive. + * + * @generated from field: optional int32 end = 2; + */ + end: number; +}; +/** + * Range of reserved numeric values. Reserved values may not be used by + * entries in the same enum. Reserved ranges may not overlap. + * + * Note that this is distinct from DescriptorProto.ReservedRange in that it + * is inclusive such that it can appropriately represent the entire int32 + * domain. + * + * @generated from message google.protobuf.EnumDescriptorProto.EnumReservedRange + */ +export type EnumDescriptorProto_EnumReservedRangeJson = { + /** + * Inclusive. + * + * @generated from field: optional int32 start = 1; + */ + start?: number; + /** + * Inclusive. + * + * @generated from field: optional int32 end = 2; + */ + end?: number; +}; +/** + * Describes the message google.protobuf.EnumDescriptorProto.EnumReservedRange. + * Use `create(EnumDescriptorProto_EnumReservedRangeSchema)` to create a new message. + */ +export declare const EnumDescriptorProto_EnumReservedRangeSchema: GenMessage; +/** + * Describes a value within an enum. + * + * @generated from message google.protobuf.EnumValueDescriptorProto + */ +export type EnumValueDescriptorProto = Message<"google.protobuf.EnumValueDescriptorProto"> & { + /** + * @generated from field: optional string name = 1; + */ + name: string; + /** + * @generated from field: optional int32 number = 2; + */ + number: number; + /** + * @generated from field: optional google.protobuf.EnumValueOptions options = 3; + */ + options?: EnumValueOptions; +}; +/** + * Describes a value within an enum. + * + * @generated from message google.protobuf.EnumValueDescriptorProto + */ +export type EnumValueDescriptorProtoJson = { + /** + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * @generated from field: optional int32 number = 2; + */ + number?: number; + /** + * @generated from field: optional google.protobuf.EnumValueOptions options = 3; + */ + options?: EnumValueOptionsJson; +}; +/** + * Describes the message google.protobuf.EnumValueDescriptorProto. + * Use `create(EnumValueDescriptorProtoSchema)` to create a new message. + */ +export declare const EnumValueDescriptorProtoSchema: GenMessage; +/** + * Describes a service. + * + * @generated from message google.protobuf.ServiceDescriptorProto + */ +export type ServiceDescriptorProto = Message<"google.protobuf.ServiceDescriptorProto"> & { + /** + * @generated from field: optional string name = 1; + */ + name: string; + /** + * @generated from field: repeated google.protobuf.MethodDescriptorProto method = 2; + */ + method: MethodDescriptorProto[]; + /** + * @generated from field: optional google.protobuf.ServiceOptions options = 3; + */ + options?: ServiceOptions; +}; +/** + * Describes a service. + * + * @generated from message google.protobuf.ServiceDescriptorProto + */ +export type ServiceDescriptorProtoJson = { + /** + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * @generated from field: repeated google.protobuf.MethodDescriptorProto method = 2; + */ + method?: MethodDescriptorProtoJson[]; + /** + * @generated from field: optional google.protobuf.ServiceOptions options = 3; + */ + options?: ServiceOptionsJson; +}; +/** + * Describes the message google.protobuf.ServiceDescriptorProto. + * Use `create(ServiceDescriptorProtoSchema)` to create a new message. + */ +export declare const ServiceDescriptorProtoSchema: GenMessage; +/** + * Describes a method of a service. + * + * @generated from message google.protobuf.MethodDescriptorProto + */ +export type MethodDescriptorProto = Message<"google.protobuf.MethodDescriptorProto"> & { + /** + * @generated from field: optional string name = 1; + */ + name: string; + /** + * Input and output type names. These are resolved in the same way as + * FieldDescriptorProto.type_name, but must refer to a message type. + * + * @generated from field: optional string input_type = 2; + */ + inputType: string; + /** + * @generated from field: optional string output_type = 3; + */ + outputType: string; + /** + * @generated from field: optional google.protobuf.MethodOptions options = 4; + */ + options?: MethodOptions; + /** + * Identifies if client streams multiple client messages + * + * @generated from field: optional bool client_streaming = 5 [default = false]; + */ + clientStreaming: boolean; + /** + * Identifies if server streams multiple server messages + * + * @generated from field: optional bool server_streaming = 6 [default = false]; + */ + serverStreaming: boolean; +}; +/** + * Describes a method of a service. + * + * @generated from message google.protobuf.MethodDescriptorProto + */ +export type MethodDescriptorProtoJson = { + /** + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * Input and output type names. These are resolved in the same way as + * FieldDescriptorProto.type_name, but must refer to a message type. + * + * @generated from field: optional string input_type = 2; + */ + inputType?: string; + /** + * @generated from field: optional string output_type = 3; + */ + outputType?: string; + /** + * @generated from field: optional google.protobuf.MethodOptions options = 4; + */ + options?: MethodOptionsJson; + /** + * Identifies if client streams multiple client messages + * + * @generated from field: optional bool client_streaming = 5 [default = false]; + */ + clientStreaming?: boolean; + /** + * Identifies if server streams multiple server messages + * + * @generated from field: optional bool server_streaming = 6 [default = false]; + */ + serverStreaming?: boolean; +}; +/** + * Describes the message google.protobuf.MethodDescriptorProto. + * Use `create(MethodDescriptorProtoSchema)` to create a new message. + */ +export declare const MethodDescriptorProtoSchema: GenMessage; +/** + * @generated from message google.protobuf.FileOptions + */ +export type FileOptions = Message<"google.protobuf.FileOptions"> & { + /** + * Sets the Java package where classes generated from this .proto will be + * placed. By default, the proto package is used, but this is often + * inappropriate because proto packages do not normally start with backwards + * domain names. + * + * @generated from field: optional string java_package = 1; + */ + javaPackage: string; + /** + * Controls the name of the wrapper Java class generated for the .proto file. + * That class will always contain the .proto file's getDescriptor() method as + * well as any top-level extensions defined in the .proto file. + * If java_multiple_files is disabled, then all the other classes from the + * .proto file will be nested inside the single wrapper outer class. + * + * @generated from field: optional string java_outer_classname = 8; + */ + javaOuterClassname: string; + /** + * If enabled, then the Java code generator will generate a separate .java + * file for each top-level message, enum, and service defined in the .proto + * file. Thus, these types will *not* be nested inside the wrapper class + * named by java_outer_classname. However, the wrapper class will still be + * generated to contain the file's getDescriptor() method as well as any + * top-level extensions defined in the file. + * + * @generated from field: optional bool java_multiple_files = 10 [default = false]; + */ + javaMultipleFiles: boolean; + /** + * This option does nothing. + * + * @generated from field: optional bool java_generate_equals_and_hash = 20 [deprecated = true]; + * @deprecated + */ + javaGenerateEqualsAndHash: boolean; + /** + * A proto2 file can set this to true to opt in to UTF-8 checking for Java, + * which will throw an exception if invalid UTF-8 is parsed from the wire or + * assigned to a string field. + * + * TODO: clarify exactly what kinds of field types this option + * applies to, and update these docs accordingly. + * + * Proto3 files already perform these checks. Setting the option explicitly to + * false has no effect: it cannot be used to opt proto3 files out of UTF-8 + * checks. + * + * @generated from field: optional bool java_string_check_utf8 = 27 [default = false]; + */ + javaStringCheckUtf8: boolean; + /** + * @generated from field: optional google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED]; + */ + optimizeFor: FileOptions_OptimizeMode; + /** + * Sets the Go package where structs generated from this .proto will be + * placed. If omitted, the Go package will be derived from the following: + * - The basename of the package import path, if provided. + * - Otherwise, the package statement in the .proto file, if present. + * - Otherwise, the basename of the .proto file, without extension. + * + * @generated from field: optional string go_package = 11; + */ + goPackage: string; + /** + * Should generic services be generated in each language? "Generic" services + * are not specific to any particular RPC system. They are generated by the + * main code generators in each language (without additional plugins). + * Generic services were the only kind of service generation supported by + * early versions of google.protobuf. + * + * Generic services are now considered deprecated in favor of using plugins + * that generate code specific to your particular RPC system. Therefore, + * these default to false. Old code which depends on generic services should + * explicitly set them to true. + * + * @generated from field: optional bool cc_generic_services = 16 [default = false]; + */ + ccGenericServices: boolean; + /** + * @generated from field: optional bool java_generic_services = 17 [default = false]; + */ + javaGenericServices: boolean; + /** + * @generated from field: optional bool py_generic_services = 18 [default = false]; + */ + pyGenericServices: boolean; + /** + * Is this file deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for everything in the file, or it will be completely ignored; in the very + * least, this is a formalization for deprecating files. + * + * @generated from field: optional bool deprecated = 23 [default = false]; + */ + deprecated: boolean; + /** + * Enables the use of arenas for the proto messages in this file. This applies + * only to generated classes for C++. + * + * @generated from field: optional bool cc_enable_arenas = 31 [default = true]; + */ + ccEnableArenas: boolean; + /** + * Sets the objective c class prefix which is prepended to all objective c + * generated classes from this .proto. There is no default. + * + * @generated from field: optional string objc_class_prefix = 36; + */ + objcClassPrefix: string; + /** + * Namespace for generated classes; defaults to the package. + * + * @generated from field: optional string csharp_namespace = 37; + */ + csharpNamespace: string; + /** + * By default Swift generators will take the proto package and CamelCase it + * replacing '.' with underscore and use that to prefix the types/symbols + * defined. When this options is provided, they will use this value instead + * to prefix the types/symbols defined. + * + * @generated from field: optional string swift_prefix = 39; + */ + swiftPrefix: string; + /** + * Sets the php class prefix which is prepended to all php generated classes + * from this .proto. Default is empty. + * + * @generated from field: optional string php_class_prefix = 40; + */ + phpClassPrefix: string; + /** + * Use this option to change the namespace of php generated classes. Default + * is empty. When this option is empty, the package name will be used for + * determining the namespace. + * + * @generated from field: optional string php_namespace = 41; + */ + phpNamespace: string; + /** + * Use this option to change the namespace of php generated metadata classes. + * Default is empty. When this option is empty, the proto file name will be + * used for determining the namespace. + * + * @generated from field: optional string php_metadata_namespace = 44; + */ + phpMetadataNamespace: string; + /** + * Use this option to change the package of ruby generated classes. Default + * is empty. When this option is not set, the package name will be used for + * determining the ruby package. + * + * @generated from field: optional string ruby_package = 45; + */ + rubyPackage: string; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 50; + */ + features?: FeatureSet; + /** + * The parser stores options it doesn't recognize here. + * See the documentation for the "Options" section above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; +}; +/** + * @generated from message google.protobuf.FileOptions + */ +export type FileOptionsJson = { + /** + * Sets the Java package where classes generated from this .proto will be + * placed. By default, the proto package is used, but this is often + * inappropriate because proto packages do not normally start with backwards + * domain names. + * + * @generated from field: optional string java_package = 1; + */ + javaPackage?: string; + /** + * Controls the name of the wrapper Java class generated for the .proto file. + * That class will always contain the .proto file's getDescriptor() method as + * well as any top-level extensions defined in the .proto file. + * If java_multiple_files is disabled, then all the other classes from the + * .proto file will be nested inside the single wrapper outer class. + * + * @generated from field: optional string java_outer_classname = 8; + */ + javaOuterClassname?: string; + /** + * If enabled, then the Java code generator will generate a separate .java + * file for each top-level message, enum, and service defined in the .proto + * file. Thus, these types will *not* be nested inside the wrapper class + * named by java_outer_classname. However, the wrapper class will still be + * generated to contain the file's getDescriptor() method as well as any + * top-level extensions defined in the file. + * + * @generated from field: optional bool java_multiple_files = 10 [default = false]; + */ + javaMultipleFiles?: boolean; + /** + * This option does nothing. + * + * @generated from field: optional bool java_generate_equals_and_hash = 20 [deprecated = true]; + * @deprecated + */ + javaGenerateEqualsAndHash?: boolean; + /** + * A proto2 file can set this to true to opt in to UTF-8 checking for Java, + * which will throw an exception if invalid UTF-8 is parsed from the wire or + * assigned to a string field. + * + * TODO: clarify exactly what kinds of field types this option + * applies to, and update these docs accordingly. + * + * Proto3 files already perform these checks. Setting the option explicitly to + * false has no effect: it cannot be used to opt proto3 files out of UTF-8 + * checks. + * + * @generated from field: optional bool java_string_check_utf8 = 27 [default = false]; + */ + javaStringCheckUtf8?: boolean; + /** + * @generated from field: optional google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED]; + */ + optimizeFor?: FileOptions_OptimizeModeJson; + /** + * Sets the Go package where structs generated from this .proto will be + * placed. If omitted, the Go package will be derived from the following: + * - The basename of the package import path, if provided. + * - Otherwise, the package statement in the .proto file, if present. + * - Otherwise, the basename of the .proto file, without extension. + * + * @generated from field: optional string go_package = 11; + */ + goPackage?: string; + /** + * Should generic services be generated in each language? "Generic" services + * are not specific to any particular RPC system. They are generated by the + * main code generators in each language (without additional plugins). + * Generic services were the only kind of service generation supported by + * early versions of google.protobuf. + * + * Generic services are now considered deprecated in favor of using plugins + * that generate code specific to your particular RPC system. Therefore, + * these default to false. Old code which depends on generic services should + * explicitly set them to true. + * + * @generated from field: optional bool cc_generic_services = 16 [default = false]; + */ + ccGenericServices?: boolean; + /** + * @generated from field: optional bool java_generic_services = 17 [default = false]; + */ + javaGenericServices?: boolean; + /** + * @generated from field: optional bool py_generic_services = 18 [default = false]; + */ + pyGenericServices?: boolean; + /** + * Is this file deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for everything in the file, or it will be completely ignored; in the very + * least, this is a formalization for deprecating files. + * + * @generated from field: optional bool deprecated = 23 [default = false]; + */ + deprecated?: boolean; + /** + * Enables the use of arenas for the proto messages in this file. This applies + * only to generated classes for C++. + * + * @generated from field: optional bool cc_enable_arenas = 31 [default = true]; + */ + ccEnableArenas?: boolean; + /** + * Sets the objective c class prefix which is prepended to all objective c + * generated classes from this .proto. There is no default. + * + * @generated from field: optional string objc_class_prefix = 36; + */ + objcClassPrefix?: string; + /** + * Namespace for generated classes; defaults to the package. + * + * @generated from field: optional string csharp_namespace = 37; + */ + csharpNamespace?: string; + /** + * By default Swift generators will take the proto package and CamelCase it + * replacing '.' with underscore and use that to prefix the types/symbols + * defined. When this options is provided, they will use this value instead + * to prefix the types/symbols defined. + * + * @generated from field: optional string swift_prefix = 39; + */ + swiftPrefix?: string; + /** + * Sets the php class prefix which is prepended to all php generated classes + * from this .proto. Default is empty. + * + * @generated from field: optional string php_class_prefix = 40; + */ + phpClassPrefix?: string; + /** + * Use this option to change the namespace of php generated classes. Default + * is empty. When this option is empty, the package name will be used for + * determining the namespace. + * + * @generated from field: optional string php_namespace = 41; + */ + phpNamespace?: string; + /** + * Use this option to change the namespace of php generated metadata classes. + * Default is empty. When this option is empty, the proto file name will be + * used for determining the namespace. + * + * @generated from field: optional string php_metadata_namespace = 44; + */ + phpMetadataNamespace?: string; + /** + * Use this option to change the package of ruby generated classes. Default + * is empty. When this option is not set, the package name will be used for + * determining the ruby package. + * + * @generated from field: optional string ruby_package = 45; + */ + rubyPackage?: string; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 50; + */ + features?: FeatureSetJson; + /** + * The parser stores options it doesn't recognize here. + * See the documentation for the "Options" section above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; +}; +/** + * Describes the message google.protobuf.FileOptions. + * Use `create(FileOptionsSchema)` to create a new message. + */ +export declare const FileOptionsSchema: GenMessage; +/** + * Generated classes can be optimized for speed or code size. + * + * @generated from enum google.protobuf.FileOptions.OptimizeMode + */ +export declare enum FileOptions_OptimizeMode { + /** + * Generate complete code for parsing, serialization, + * + * @generated from enum value: SPEED = 1; + */ + SPEED = 1, + /** + * etc. + * + * Use ReflectionOps to implement these methods. + * + * @generated from enum value: CODE_SIZE = 2; + */ + CODE_SIZE = 2, + /** + * Generate code using MessageLite and the lite runtime. + * + * @generated from enum value: LITE_RUNTIME = 3; + */ + LITE_RUNTIME = 3 +} +/** + * Generated classes can be optimized for speed or code size. + * + * @generated from enum google.protobuf.FileOptions.OptimizeMode + */ +export type FileOptions_OptimizeModeJson = "SPEED" | "CODE_SIZE" | "LITE_RUNTIME"; +/** + * Describes the enum google.protobuf.FileOptions.OptimizeMode. + */ +export declare const FileOptions_OptimizeModeSchema: GenEnum; +/** + * @generated from message google.protobuf.MessageOptions + */ +export type MessageOptions = Message<"google.protobuf.MessageOptions"> & { + /** + * Set true to use the old proto1 MessageSet wire format for extensions. + * This is provided for backwards-compatibility with the MessageSet wire + * format. You should not use this for any other reason: It's less + * efficient, has fewer features, and is more complicated. + * + * The message must be defined exactly as follows: + * message Foo { + * option message_set_wire_format = true; + * extensions 4 to max; + * } + * Note that the message cannot have any defined fields; MessageSets only + * have extensions. + * + * All extensions of your type must be singular messages; e.g. they cannot + * be int32s, enums, or repeated messages. + * + * Because this is an option, the above two restrictions are not enforced by + * the protocol compiler. + * + * @generated from field: optional bool message_set_wire_format = 1 [default = false]; + */ + messageSetWireFormat: boolean; + /** + * Disables the generation of the standard "descriptor()" accessor, which can + * conflict with a field of the same name. This is meant to make migration + * from proto1 easier; new code should avoid fields named "descriptor". + * + * @generated from field: optional bool no_standard_descriptor_accessor = 2 [default = false]; + */ + noStandardDescriptorAccessor: boolean; + /** + * Is this message deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the message, or it will be completely ignored; in the very least, + * this is a formalization for deprecating messages. + * + * @generated from field: optional bool deprecated = 3 [default = false]; + */ + deprecated: boolean; + /** + * Whether the message is an automatically generated map entry type for the + * maps field. + * + * For maps fields: + * map map_field = 1; + * The parsed descriptor looks like: + * message MapFieldEntry { + * option map_entry = true; + * optional KeyType key = 1; + * optional ValueType value = 2; + * } + * repeated MapFieldEntry map_field = 1; + * + * Implementations may choose not to generate the map_entry=true message, but + * use a native map in the target language to hold the keys and values. + * The reflection APIs in such implementations still need to work as + * if the field is a repeated message field. + * + * NOTE: Do not set the option in .proto files. Always use the maps syntax + * instead. The option should only be implicitly set by the proto compiler + * parser. + * + * @generated from field: optional bool map_entry = 7; + */ + mapEntry: boolean; + /** + * Enable the legacy handling of JSON field name conflicts. This lowercases + * and strips underscored from the fields before comparison in proto3 only. + * The new behavior takes `json_name` into account and applies to proto2 as + * well. + * + * This should only be used as a temporary measure against broken builds due + * to the change in behavior for JSON field name conflicts. + * + * TODO This is legacy behavior we plan to remove once downstream + * teams have had time to migrate. + * + * @generated from field: optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true]; + * @deprecated + */ + deprecatedLegacyJsonFieldConflicts: boolean; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 12; + */ + features?: FeatureSet; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; +}; +/** + * @generated from message google.protobuf.MessageOptions + */ +export type MessageOptionsJson = { + /** + * Set true to use the old proto1 MessageSet wire format for extensions. + * This is provided for backwards-compatibility with the MessageSet wire + * format. You should not use this for any other reason: It's less + * efficient, has fewer features, and is more complicated. + * + * The message must be defined exactly as follows: + * message Foo { + * option message_set_wire_format = true; + * extensions 4 to max; + * } + * Note that the message cannot have any defined fields; MessageSets only + * have extensions. + * + * All extensions of your type must be singular messages; e.g. they cannot + * be int32s, enums, or repeated messages. + * + * Because this is an option, the above two restrictions are not enforced by + * the protocol compiler. + * + * @generated from field: optional bool message_set_wire_format = 1 [default = false]; + */ + messageSetWireFormat?: boolean; + /** + * Disables the generation of the standard "descriptor()" accessor, which can + * conflict with a field of the same name. This is meant to make migration + * from proto1 easier; new code should avoid fields named "descriptor". + * + * @generated from field: optional bool no_standard_descriptor_accessor = 2 [default = false]; + */ + noStandardDescriptorAccessor?: boolean; + /** + * Is this message deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the message, or it will be completely ignored; in the very least, + * this is a formalization for deprecating messages. + * + * @generated from field: optional bool deprecated = 3 [default = false]; + */ + deprecated?: boolean; + /** + * Whether the message is an automatically generated map entry type for the + * maps field. + * + * For maps fields: + * map map_field = 1; + * The parsed descriptor looks like: + * message MapFieldEntry { + * option map_entry = true; + * optional KeyType key = 1; + * optional ValueType value = 2; + * } + * repeated MapFieldEntry map_field = 1; + * + * Implementations may choose not to generate the map_entry=true message, but + * use a native map in the target language to hold the keys and values. + * The reflection APIs in such implementations still need to work as + * if the field is a repeated message field. + * + * NOTE: Do not set the option in .proto files. Always use the maps syntax + * instead. The option should only be implicitly set by the proto compiler + * parser. + * + * @generated from field: optional bool map_entry = 7; + */ + mapEntry?: boolean; + /** + * Enable the legacy handling of JSON field name conflicts. This lowercases + * and strips underscored from the fields before comparison in proto3 only. + * The new behavior takes `json_name` into account and applies to proto2 as + * well. + * + * This should only be used as a temporary measure against broken builds due + * to the change in behavior for JSON field name conflicts. + * + * TODO This is legacy behavior we plan to remove once downstream + * teams have had time to migrate. + * + * @generated from field: optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true]; + * @deprecated + */ + deprecatedLegacyJsonFieldConflicts?: boolean; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 12; + */ + features?: FeatureSetJson; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; +}; +/** + * Describes the message google.protobuf.MessageOptions. + * Use `create(MessageOptionsSchema)` to create a new message. + */ +export declare const MessageOptionsSchema: GenMessage; +/** + * @generated from message google.protobuf.FieldOptions + */ +export type FieldOptions = Message<"google.protobuf.FieldOptions"> & { + /** + * NOTE: ctype is deprecated. Use `features.(pb.cpp).string_type` instead. + * The ctype option instructs the C++ code generator to use a different + * representation of the field than it normally would. See the specific + * options below. This option is only implemented to support use of + * [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of + * type "bytes" in the open source release. + * TODO: make ctype actually deprecated. + * + * @generated from field: optional google.protobuf.FieldOptions.CType ctype = 1 [default = STRING]; + */ + ctype: FieldOptions_CType; + /** + * The packed option can be enabled for repeated primitive fields to enable + * a more efficient representation on the wire. Rather than repeatedly + * writing the tag and type for each element, the entire array is encoded as + * a single length-delimited blob. In proto3, only explicit setting it to + * false will avoid using packed encoding. This option is prohibited in + * Editions, but the `repeated_field_encoding` feature can be used to control + * the behavior. + * + * @generated from field: optional bool packed = 2; + */ + packed: boolean; + /** + * The jstype option determines the JavaScript type used for values of the + * field. The option is permitted only for 64 bit integral and fixed types + * (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING + * is represented as JavaScript string, which avoids loss of precision that + * can happen when a large value is converted to a floating point JavaScript. + * Specifying JS_NUMBER for the jstype causes the generated JavaScript code to + * use the JavaScript "number" type. The behavior of the default option + * JS_NORMAL is implementation dependent. + * + * This option is an enum to permit additional types to be added, e.g. + * goog.math.Integer. + * + * @generated from field: optional google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL]; + */ + jstype: FieldOptions_JSType; + /** + * Should this field be parsed lazily? Lazy applies only to message-type + * fields. It means that when the outer message is initially parsed, the + * inner message's contents will not be parsed but instead stored in encoded + * form. The inner message will actually be parsed when it is first accessed. + * + * This is only a hint. Implementations are free to choose whether to use + * eager or lazy parsing regardless of the value of this option. However, + * setting this option true suggests that the protocol author believes that + * using lazy parsing on this field is worth the additional bookkeeping + * overhead typically needed to implement it. + * + * This option does not affect the public interface of any generated code; + * all method signatures remain the same. Furthermore, thread-safety of the + * interface is not affected by this option; const methods remain safe to + * call from multiple threads concurrently, while non-const methods continue + * to require exclusive access. + * + * Note that lazy message fields are still eagerly verified to check + * ill-formed wireformat or missing required fields. Calling IsInitialized() + * on the outer message would fail if the inner message has missing required + * fields. Failed verification would result in parsing failure (except when + * uninitialized messages are acceptable). + * + * @generated from field: optional bool lazy = 5 [default = false]; + */ + lazy: boolean; + /** + * unverified_lazy does no correctness checks on the byte stream. This should + * only be used where lazy with verification is prohibitive for performance + * reasons. + * + * @generated from field: optional bool unverified_lazy = 15 [default = false]; + */ + unverifiedLazy: boolean; + /** + * Is this field deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for accessors, or it will be completely ignored; in the very least, this + * is a formalization for deprecating fields. + * + * @generated from field: optional bool deprecated = 3 [default = false]; + */ + deprecated: boolean; + /** + * For Google-internal migration only. Do not use. + * + * @generated from field: optional bool weak = 10 [default = false]; + */ + weak: boolean; + /** + * Indicate that the field value should not be printed out when using debug + * formats, e.g. when the field contains sensitive credentials. + * + * @generated from field: optional bool debug_redact = 16 [default = false]; + */ + debugRedact: boolean; + /** + * @generated from field: optional google.protobuf.FieldOptions.OptionRetention retention = 17; + */ + retention: FieldOptions_OptionRetention; + /** + * @generated from field: repeated google.protobuf.FieldOptions.OptionTargetType targets = 19; + */ + targets: FieldOptions_OptionTargetType[]; + /** + * @generated from field: repeated google.protobuf.FieldOptions.EditionDefault edition_defaults = 20; + */ + editionDefaults: FieldOptions_EditionDefault[]; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 21; + */ + features?: FeatureSet; + /** + * @generated from field: optional google.protobuf.FieldOptions.FeatureSupport feature_support = 22; + */ + featureSupport?: FieldOptions_FeatureSupport; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; +}; +/** + * @generated from message google.protobuf.FieldOptions + */ +export type FieldOptionsJson = { + /** + * NOTE: ctype is deprecated. Use `features.(pb.cpp).string_type` instead. + * The ctype option instructs the C++ code generator to use a different + * representation of the field than it normally would. See the specific + * options below. This option is only implemented to support use of + * [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of + * type "bytes" in the open source release. + * TODO: make ctype actually deprecated. + * + * @generated from field: optional google.protobuf.FieldOptions.CType ctype = 1 [default = STRING]; + */ + ctype?: FieldOptions_CTypeJson; + /** + * The packed option can be enabled for repeated primitive fields to enable + * a more efficient representation on the wire. Rather than repeatedly + * writing the tag and type for each element, the entire array is encoded as + * a single length-delimited blob. In proto3, only explicit setting it to + * false will avoid using packed encoding. This option is prohibited in + * Editions, but the `repeated_field_encoding` feature can be used to control + * the behavior. + * + * @generated from field: optional bool packed = 2; + */ + packed?: boolean; + /** + * The jstype option determines the JavaScript type used for values of the + * field. The option is permitted only for 64 bit integral and fixed types + * (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING + * is represented as JavaScript string, which avoids loss of precision that + * can happen when a large value is converted to a floating point JavaScript. + * Specifying JS_NUMBER for the jstype causes the generated JavaScript code to + * use the JavaScript "number" type. The behavior of the default option + * JS_NORMAL is implementation dependent. + * + * This option is an enum to permit additional types to be added, e.g. + * goog.math.Integer. + * + * @generated from field: optional google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL]; + */ + jstype?: FieldOptions_JSTypeJson; + /** + * Should this field be parsed lazily? Lazy applies only to message-type + * fields. It means that when the outer message is initially parsed, the + * inner message's contents will not be parsed but instead stored in encoded + * form. The inner message will actually be parsed when it is first accessed. + * + * This is only a hint. Implementations are free to choose whether to use + * eager or lazy parsing regardless of the value of this option. However, + * setting this option true suggests that the protocol author believes that + * using lazy parsing on this field is worth the additional bookkeeping + * overhead typically needed to implement it. + * + * This option does not affect the public interface of any generated code; + * all method signatures remain the same. Furthermore, thread-safety of the + * interface is not affected by this option; const methods remain safe to + * call from multiple threads concurrently, while non-const methods continue + * to require exclusive access. + * + * Note that lazy message fields are still eagerly verified to check + * ill-formed wireformat or missing required fields. Calling IsInitialized() + * on the outer message would fail if the inner message has missing required + * fields. Failed verification would result in parsing failure (except when + * uninitialized messages are acceptable). + * + * @generated from field: optional bool lazy = 5 [default = false]; + */ + lazy?: boolean; + /** + * unverified_lazy does no correctness checks on the byte stream. This should + * only be used where lazy with verification is prohibitive for performance + * reasons. + * + * @generated from field: optional bool unverified_lazy = 15 [default = false]; + */ + unverifiedLazy?: boolean; + /** + * Is this field deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for accessors, or it will be completely ignored; in the very least, this + * is a formalization for deprecating fields. + * + * @generated from field: optional bool deprecated = 3 [default = false]; + */ + deprecated?: boolean; + /** + * For Google-internal migration only. Do not use. + * + * @generated from field: optional bool weak = 10 [default = false]; + */ + weak?: boolean; + /** + * Indicate that the field value should not be printed out when using debug + * formats, e.g. when the field contains sensitive credentials. + * + * @generated from field: optional bool debug_redact = 16 [default = false]; + */ + debugRedact?: boolean; + /** + * @generated from field: optional google.protobuf.FieldOptions.OptionRetention retention = 17; + */ + retention?: FieldOptions_OptionRetentionJson; + /** + * @generated from field: repeated google.protobuf.FieldOptions.OptionTargetType targets = 19; + */ + targets?: FieldOptions_OptionTargetTypeJson[]; + /** + * @generated from field: repeated google.protobuf.FieldOptions.EditionDefault edition_defaults = 20; + */ + editionDefaults?: FieldOptions_EditionDefaultJson[]; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 21; + */ + features?: FeatureSetJson; + /** + * @generated from field: optional google.protobuf.FieldOptions.FeatureSupport feature_support = 22; + */ + featureSupport?: FieldOptions_FeatureSupportJson; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; +}; +/** + * Describes the message google.protobuf.FieldOptions. + * Use `create(FieldOptionsSchema)` to create a new message. + */ +export declare const FieldOptionsSchema: GenMessage; +/** + * @generated from message google.protobuf.FieldOptions.EditionDefault + */ +export type FieldOptions_EditionDefault = Message<"google.protobuf.FieldOptions.EditionDefault"> & { + /** + * @generated from field: optional google.protobuf.Edition edition = 3; + */ + edition: Edition; + /** + * Textproto value. + * + * @generated from field: optional string value = 2; + */ + value: string; +}; +/** + * @generated from message google.protobuf.FieldOptions.EditionDefault + */ +export type FieldOptions_EditionDefaultJson = { + /** + * @generated from field: optional google.protobuf.Edition edition = 3; + */ + edition?: EditionJson; + /** + * Textproto value. + * + * @generated from field: optional string value = 2; + */ + value?: string; +}; +/** + * Describes the message google.protobuf.FieldOptions.EditionDefault. + * Use `create(FieldOptions_EditionDefaultSchema)` to create a new message. + */ +export declare const FieldOptions_EditionDefaultSchema: GenMessage; +/** + * Information about the support window of a feature. + * + * @generated from message google.protobuf.FieldOptions.FeatureSupport + */ +export type FieldOptions_FeatureSupport = Message<"google.protobuf.FieldOptions.FeatureSupport"> & { + /** + * The edition that this feature was first available in. In editions + * earlier than this one, the default assigned to EDITION_LEGACY will be + * used, and proto files will not be able to override it. + * + * @generated from field: optional google.protobuf.Edition edition_introduced = 1; + */ + editionIntroduced: Edition; + /** + * The edition this feature becomes deprecated in. Using this after this + * edition may trigger warnings. + * + * @generated from field: optional google.protobuf.Edition edition_deprecated = 2; + */ + editionDeprecated: Edition; + /** + * The deprecation warning text if this feature is used after the edition it + * was marked deprecated in. + * + * @generated from field: optional string deprecation_warning = 3; + */ + deprecationWarning: string; + /** + * The edition this feature is no longer available in. In editions after + * this one, the last default assigned will be used, and proto files will + * not be able to override it. + * + * @generated from field: optional google.protobuf.Edition edition_removed = 4; + */ + editionRemoved: Edition; +}; +/** + * Information about the support window of a feature. + * + * @generated from message google.protobuf.FieldOptions.FeatureSupport + */ +export type FieldOptions_FeatureSupportJson = { + /** + * The edition that this feature was first available in. In editions + * earlier than this one, the default assigned to EDITION_LEGACY will be + * used, and proto files will not be able to override it. + * + * @generated from field: optional google.protobuf.Edition edition_introduced = 1; + */ + editionIntroduced?: EditionJson; + /** + * The edition this feature becomes deprecated in. Using this after this + * edition may trigger warnings. + * + * @generated from field: optional google.protobuf.Edition edition_deprecated = 2; + */ + editionDeprecated?: EditionJson; + /** + * The deprecation warning text if this feature is used after the edition it + * was marked deprecated in. + * + * @generated from field: optional string deprecation_warning = 3; + */ + deprecationWarning?: string; + /** + * The edition this feature is no longer available in. In editions after + * this one, the last default assigned will be used, and proto files will + * not be able to override it. + * + * @generated from field: optional google.protobuf.Edition edition_removed = 4; + */ + editionRemoved?: EditionJson; +}; +/** + * Describes the message google.protobuf.FieldOptions.FeatureSupport. + * Use `create(FieldOptions_FeatureSupportSchema)` to create a new message. + */ +export declare const FieldOptions_FeatureSupportSchema: GenMessage; +/** + * @generated from enum google.protobuf.FieldOptions.CType + */ +export declare enum FieldOptions_CType { + /** + * Default mode. + * + * @generated from enum value: STRING = 0; + */ + STRING = 0, + /** + * The option [ctype=CORD] may be applied to a non-repeated field of type + * "bytes". It indicates that in C++, the data should be stored in a Cord + * instead of a string. For very large strings, this may reduce memory + * fragmentation. It may also allow better performance when parsing from a + * Cord, or when parsing with aliasing enabled, as the parsed Cord may then + * alias the original buffer. + * + * @generated from enum value: CORD = 1; + */ + CORD = 1, + /** + * @generated from enum value: STRING_PIECE = 2; + */ + STRING_PIECE = 2 +} +/** + * @generated from enum google.protobuf.FieldOptions.CType + */ +export type FieldOptions_CTypeJson = "STRING" | "CORD" | "STRING_PIECE"; +/** + * Describes the enum google.protobuf.FieldOptions.CType. + */ +export declare const FieldOptions_CTypeSchema: GenEnum; +/** + * @generated from enum google.protobuf.FieldOptions.JSType + */ +export declare enum FieldOptions_JSType { + /** + * Use the default type. + * + * @generated from enum value: JS_NORMAL = 0; + */ + JS_NORMAL = 0, + /** + * Use JavaScript strings. + * + * @generated from enum value: JS_STRING = 1; + */ + JS_STRING = 1, + /** + * Use JavaScript numbers. + * + * @generated from enum value: JS_NUMBER = 2; + */ + JS_NUMBER = 2 +} +/** + * @generated from enum google.protobuf.FieldOptions.JSType + */ +export type FieldOptions_JSTypeJson = "JS_NORMAL" | "JS_STRING" | "JS_NUMBER"; +/** + * Describes the enum google.protobuf.FieldOptions.JSType. + */ +export declare const FieldOptions_JSTypeSchema: GenEnum; +/** + * If set to RETENTION_SOURCE, the option will be omitted from the binary. + * + * @generated from enum google.protobuf.FieldOptions.OptionRetention + */ +export declare enum FieldOptions_OptionRetention { + /** + * @generated from enum value: RETENTION_UNKNOWN = 0; + */ + RETENTION_UNKNOWN = 0, + /** + * @generated from enum value: RETENTION_RUNTIME = 1; + */ + RETENTION_RUNTIME = 1, + /** + * @generated from enum value: RETENTION_SOURCE = 2; + */ + RETENTION_SOURCE = 2 +} +/** + * If set to RETENTION_SOURCE, the option will be omitted from the binary. + * + * @generated from enum google.protobuf.FieldOptions.OptionRetention + */ +export type FieldOptions_OptionRetentionJson = "RETENTION_UNKNOWN" | "RETENTION_RUNTIME" | "RETENTION_SOURCE"; +/** + * Describes the enum google.protobuf.FieldOptions.OptionRetention. + */ +export declare const FieldOptions_OptionRetentionSchema: GenEnum; +/** + * This indicates the types of entities that the field may apply to when used + * as an option. If it is unset, then the field may be freely used as an + * option on any kind of entity. + * + * @generated from enum google.protobuf.FieldOptions.OptionTargetType + */ +export declare enum FieldOptions_OptionTargetType { + /** + * @generated from enum value: TARGET_TYPE_UNKNOWN = 0; + */ + TARGET_TYPE_UNKNOWN = 0, + /** + * @generated from enum value: TARGET_TYPE_FILE = 1; + */ + TARGET_TYPE_FILE = 1, + /** + * @generated from enum value: TARGET_TYPE_EXTENSION_RANGE = 2; + */ + TARGET_TYPE_EXTENSION_RANGE = 2, + /** + * @generated from enum value: TARGET_TYPE_MESSAGE = 3; + */ + TARGET_TYPE_MESSAGE = 3, + /** + * @generated from enum value: TARGET_TYPE_FIELD = 4; + */ + TARGET_TYPE_FIELD = 4, + /** + * @generated from enum value: TARGET_TYPE_ONEOF = 5; + */ + TARGET_TYPE_ONEOF = 5, + /** + * @generated from enum value: TARGET_TYPE_ENUM = 6; + */ + TARGET_TYPE_ENUM = 6, + /** + * @generated from enum value: TARGET_TYPE_ENUM_ENTRY = 7; + */ + TARGET_TYPE_ENUM_ENTRY = 7, + /** + * @generated from enum value: TARGET_TYPE_SERVICE = 8; + */ + TARGET_TYPE_SERVICE = 8, + /** + * @generated from enum value: TARGET_TYPE_METHOD = 9; + */ + TARGET_TYPE_METHOD = 9 +} +/** + * This indicates the types of entities that the field may apply to when used + * as an option. If it is unset, then the field may be freely used as an + * option on any kind of entity. + * + * @generated from enum google.protobuf.FieldOptions.OptionTargetType + */ +export type FieldOptions_OptionTargetTypeJson = "TARGET_TYPE_UNKNOWN" | "TARGET_TYPE_FILE" | "TARGET_TYPE_EXTENSION_RANGE" | "TARGET_TYPE_MESSAGE" | "TARGET_TYPE_FIELD" | "TARGET_TYPE_ONEOF" | "TARGET_TYPE_ENUM" | "TARGET_TYPE_ENUM_ENTRY" | "TARGET_TYPE_SERVICE" | "TARGET_TYPE_METHOD"; +/** + * Describes the enum google.protobuf.FieldOptions.OptionTargetType. + */ +export declare const FieldOptions_OptionTargetTypeSchema: GenEnum; +/** + * @generated from message google.protobuf.OneofOptions + */ +export type OneofOptions = Message<"google.protobuf.OneofOptions"> & { + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 1; + */ + features?: FeatureSet; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; +}; +/** + * @generated from message google.protobuf.OneofOptions + */ +export type OneofOptionsJson = { + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 1; + */ + features?: FeatureSetJson; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; +}; +/** + * Describes the message google.protobuf.OneofOptions. + * Use `create(OneofOptionsSchema)` to create a new message. + */ +export declare const OneofOptionsSchema: GenMessage; +/** + * @generated from message google.protobuf.EnumOptions + */ +export type EnumOptions = Message<"google.protobuf.EnumOptions"> & { + /** + * Set this option to true to allow mapping different tag names to the same + * value. + * + * @generated from field: optional bool allow_alias = 2; + */ + allowAlias: boolean; + /** + * Is this enum deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the enum, or it will be completely ignored; in the very least, this + * is a formalization for deprecating enums. + * + * @generated from field: optional bool deprecated = 3 [default = false]; + */ + deprecated: boolean; + /** + * Enable the legacy handling of JSON field name conflicts. This lowercases + * and strips underscored from the fields before comparison in proto3 only. + * The new behavior takes `json_name` into account and applies to proto2 as + * well. + * TODO Remove this legacy behavior once downstream teams have + * had time to migrate. + * + * @generated from field: optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true]; + * @deprecated + */ + deprecatedLegacyJsonFieldConflicts: boolean; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 7; + */ + features?: FeatureSet; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; +}; +/** + * @generated from message google.protobuf.EnumOptions + */ +export type EnumOptionsJson = { + /** + * Set this option to true to allow mapping different tag names to the same + * value. + * + * @generated from field: optional bool allow_alias = 2; + */ + allowAlias?: boolean; + /** + * Is this enum deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the enum, or it will be completely ignored; in the very least, this + * is a formalization for deprecating enums. + * + * @generated from field: optional bool deprecated = 3 [default = false]; + */ + deprecated?: boolean; + /** + * Enable the legacy handling of JSON field name conflicts. This lowercases + * and strips underscored from the fields before comparison in proto3 only. + * The new behavior takes `json_name` into account and applies to proto2 as + * well. + * TODO Remove this legacy behavior once downstream teams have + * had time to migrate. + * + * @generated from field: optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true]; + * @deprecated + */ + deprecatedLegacyJsonFieldConflicts?: boolean; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 7; + */ + features?: FeatureSetJson; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; +}; +/** + * Describes the message google.protobuf.EnumOptions. + * Use `create(EnumOptionsSchema)` to create a new message. + */ +export declare const EnumOptionsSchema: GenMessage; +/** + * @generated from message google.protobuf.EnumValueOptions + */ +export type EnumValueOptions = Message<"google.protobuf.EnumValueOptions"> & { + /** + * Is this enum value deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the enum value, or it will be completely ignored; in the very least, + * this is a formalization for deprecating enum values. + * + * @generated from field: optional bool deprecated = 1 [default = false]; + */ + deprecated: boolean; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 2; + */ + features?: FeatureSet; + /** + * Indicate that fields annotated with this enum value should not be printed + * out when using debug formats, e.g. when the field contains sensitive + * credentials. + * + * @generated from field: optional bool debug_redact = 3 [default = false]; + */ + debugRedact: boolean; + /** + * Information about the support window of a feature value. + * + * @generated from field: optional google.protobuf.FieldOptions.FeatureSupport feature_support = 4; + */ + featureSupport?: FieldOptions_FeatureSupport; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; +}; +/** + * @generated from message google.protobuf.EnumValueOptions + */ +export type EnumValueOptionsJson = { + /** + * Is this enum value deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the enum value, or it will be completely ignored; in the very least, + * this is a formalization for deprecating enum values. + * + * @generated from field: optional bool deprecated = 1 [default = false]; + */ + deprecated?: boolean; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 2; + */ + features?: FeatureSetJson; + /** + * Indicate that fields annotated with this enum value should not be printed + * out when using debug formats, e.g. when the field contains sensitive + * credentials. + * + * @generated from field: optional bool debug_redact = 3 [default = false]; + */ + debugRedact?: boolean; + /** + * Information about the support window of a feature value. + * + * @generated from field: optional google.protobuf.FieldOptions.FeatureSupport feature_support = 4; + */ + featureSupport?: FieldOptions_FeatureSupportJson; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; +}; +/** + * Describes the message google.protobuf.EnumValueOptions. + * Use `create(EnumValueOptionsSchema)` to create a new message. + */ +export declare const EnumValueOptionsSchema: GenMessage; +/** + * @generated from message google.protobuf.ServiceOptions + */ +export type ServiceOptions = Message<"google.protobuf.ServiceOptions"> & { + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 34; + */ + features?: FeatureSet; + /** + * Is this service deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the service, or it will be completely ignored; in the very least, + * this is a formalization for deprecating services. + * + * @generated from field: optional bool deprecated = 33 [default = false]; + */ + deprecated: boolean; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; +}; +/** + * @generated from message google.protobuf.ServiceOptions + */ +export type ServiceOptionsJson = { + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 34; + */ + features?: FeatureSetJson; + /** + * Is this service deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the service, or it will be completely ignored; in the very least, + * this is a formalization for deprecating services. + * + * @generated from field: optional bool deprecated = 33 [default = false]; + */ + deprecated?: boolean; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; +}; +/** + * Describes the message google.protobuf.ServiceOptions. + * Use `create(ServiceOptionsSchema)` to create a new message. + */ +export declare const ServiceOptionsSchema: GenMessage; +/** + * @generated from message google.protobuf.MethodOptions + */ +export type MethodOptions = Message<"google.protobuf.MethodOptions"> & { + /** + * Is this method deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the method, or it will be completely ignored; in the very least, + * this is a formalization for deprecating methods. + * + * @generated from field: optional bool deprecated = 33 [default = false]; + */ + deprecated: boolean; + /** + * @generated from field: optional google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN]; + */ + idempotencyLevel: MethodOptions_IdempotencyLevel; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 35; + */ + features?: FeatureSet; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; +}; +/** + * @generated from message google.protobuf.MethodOptions + */ +export type MethodOptionsJson = { + /** + * Is this method deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the method, or it will be completely ignored; in the very least, + * this is a formalization for deprecating methods. + * + * @generated from field: optional bool deprecated = 33 [default = false]; + */ + deprecated?: boolean; + /** + * @generated from field: optional google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN]; + */ + idempotencyLevel?: MethodOptions_IdempotencyLevelJson; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 35; + */ + features?: FeatureSetJson; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; +}; +/** + * Describes the message google.protobuf.MethodOptions. + * Use `create(MethodOptionsSchema)` to create a new message. + */ +export declare const MethodOptionsSchema: GenMessage; +/** + * Is this method side-effect-free (or safe in HTTP parlance), or idempotent, + * or neither? HTTP based RPC implementation may choose GET verb for safe + * methods, and PUT verb for idempotent methods instead of the default POST. + * + * @generated from enum google.protobuf.MethodOptions.IdempotencyLevel + */ +export declare enum MethodOptions_IdempotencyLevel { + /** + * @generated from enum value: IDEMPOTENCY_UNKNOWN = 0; + */ + IDEMPOTENCY_UNKNOWN = 0, + /** + * implies idempotent + * + * @generated from enum value: NO_SIDE_EFFECTS = 1; + */ + NO_SIDE_EFFECTS = 1, + /** + * idempotent, but may have side effects + * + * @generated from enum value: IDEMPOTENT = 2; + */ + IDEMPOTENT = 2 +} +/** + * Is this method side-effect-free (or safe in HTTP parlance), or idempotent, + * or neither? HTTP based RPC implementation may choose GET verb for safe + * methods, and PUT verb for idempotent methods instead of the default POST. + * + * @generated from enum google.protobuf.MethodOptions.IdempotencyLevel + */ +export type MethodOptions_IdempotencyLevelJson = "IDEMPOTENCY_UNKNOWN" | "NO_SIDE_EFFECTS" | "IDEMPOTENT"; +/** + * Describes the enum google.protobuf.MethodOptions.IdempotencyLevel. + */ +export declare const MethodOptions_IdempotencyLevelSchema: GenEnum; +/** + * A message representing a option the parser does not recognize. This only + * appears in options protos created by the compiler::Parser class. + * DescriptorPool resolves these when building Descriptor objects. Therefore, + * options protos in descriptor objects (e.g. returned by Descriptor::options(), + * or produced by Descriptor::CopyTo()) will never have UninterpretedOptions + * in them. + * + * @generated from message google.protobuf.UninterpretedOption + */ +export type UninterpretedOption = Message<"google.protobuf.UninterpretedOption"> & { + /** + * @generated from field: repeated google.protobuf.UninterpretedOption.NamePart name = 2; + */ + name: UninterpretedOption_NamePart[]; + /** + * The value of the uninterpreted option, in whatever type the tokenizer + * identified it as during parsing. Exactly one of these should be set. + * + * @generated from field: optional string identifier_value = 3; + */ + identifierValue: string; + /** + * @generated from field: optional uint64 positive_int_value = 4; + */ + positiveIntValue: bigint; + /** + * @generated from field: optional int64 negative_int_value = 5; + */ + negativeIntValue: bigint; + /** + * @generated from field: optional double double_value = 6; + */ + doubleValue: number; + /** + * @generated from field: optional bytes string_value = 7; + */ + stringValue: Uint8Array; + /** + * @generated from field: optional string aggregate_value = 8; + */ + aggregateValue: string; +}; +/** + * A message representing a option the parser does not recognize. This only + * appears in options protos created by the compiler::Parser class. + * DescriptorPool resolves these when building Descriptor objects. Therefore, + * options protos in descriptor objects (e.g. returned by Descriptor::options(), + * or produced by Descriptor::CopyTo()) will never have UninterpretedOptions + * in them. + * + * @generated from message google.protobuf.UninterpretedOption + */ +export type UninterpretedOptionJson = { + /** + * @generated from field: repeated google.protobuf.UninterpretedOption.NamePart name = 2; + */ + name?: UninterpretedOption_NamePartJson[]; + /** + * The value of the uninterpreted option, in whatever type the tokenizer + * identified it as during parsing. Exactly one of these should be set. + * + * @generated from field: optional string identifier_value = 3; + */ + identifierValue?: string; + /** + * @generated from field: optional uint64 positive_int_value = 4; + */ + positiveIntValue?: string; + /** + * @generated from field: optional int64 negative_int_value = 5; + */ + negativeIntValue?: string; + /** + * @generated from field: optional double double_value = 6; + */ + doubleValue?: number | "NaN" | "Infinity" | "-Infinity"; + /** + * @generated from field: optional bytes string_value = 7; + */ + stringValue?: string; + /** + * @generated from field: optional string aggregate_value = 8; + */ + aggregateValue?: string; +}; +/** + * Describes the message google.protobuf.UninterpretedOption. + * Use `create(UninterpretedOptionSchema)` to create a new message. + */ +export declare const UninterpretedOptionSchema: GenMessage; +/** + * The name of the uninterpreted option. Each string represents a segment in + * a dot-separated name. is_extension is true iff a segment represents an + * extension (denoted with parentheses in options specs in .proto files). + * E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents + * "foo.(bar.baz).moo". + * + * @generated from message google.protobuf.UninterpretedOption.NamePart + */ +export type UninterpretedOption_NamePart = Message<"google.protobuf.UninterpretedOption.NamePart"> & { + /** + * @generated from field: required string name_part = 1; + */ + namePart: string; + /** + * @generated from field: required bool is_extension = 2; + */ + isExtension: boolean; +}; +/** + * The name of the uninterpreted option. Each string represents a segment in + * a dot-separated name. is_extension is true iff a segment represents an + * extension (denoted with parentheses in options specs in .proto files). + * E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents + * "foo.(bar.baz).moo". + * + * @generated from message google.protobuf.UninterpretedOption.NamePart + */ +export type UninterpretedOption_NamePartJson = { + /** + * @generated from field: required string name_part = 1; + */ + namePart?: string; + /** + * @generated from field: required bool is_extension = 2; + */ + isExtension?: boolean; +}; +/** + * Describes the message google.protobuf.UninterpretedOption.NamePart. + * Use `create(UninterpretedOption_NamePartSchema)` to create a new message. + */ +export declare const UninterpretedOption_NamePartSchema: GenMessage; +/** + * TODO Enums in C++ gencode (and potentially other languages) are + * not well scoped. This means that each of the feature enums below can clash + * with each other. The short names we've chosen maximize call-site + * readability, but leave us very open to this scenario. A future feature will + * be designed and implemented to handle this, hopefully before we ever hit a + * conflict here. + * + * @generated from message google.protobuf.FeatureSet + */ +export type FeatureSet = Message<"google.protobuf.FeatureSet"> & { + /** + * @generated from field: optional google.protobuf.FeatureSet.FieldPresence field_presence = 1; + */ + fieldPresence: FeatureSet_FieldPresence; + /** + * @generated from field: optional google.protobuf.FeatureSet.EnumType enum_type = 2; + */ + enumType: FeatureSet_EnumType; + /** + * @generated from field: optional google.protobuf.FeatureSet.RepeatedFieldEncoding repeated_field_encoding = 3; + */ + repeatedFieldEncoding: FeatureSet_RepeatedFieldEncoding; + /** + * @generated from field: optional google.protobuf.FeatureSet.Utf8Validation utf8_validation = 4; + */ + utf8Validation: FeatureSet_Utf8Validation; + /** + * @generated from field: optional google.protobuf.FeatureSet.MessageEncoding message_encoding = 5; + */ + messageEncoding: FeatureSet_MessageEncoding; + /** + * @generated from field: optional google.protobuf.FeatureSet.JsonFormat json_format = 6; + */ + jsonFormat: FeatureSet_JsonFormat; + /** + * @generated from field: optional google.protobuf.FeatureSet.EnforceNamingStyle enforce_naming_style = 7; + */ + enforceNamingStyle: FeatureSet_EnforceNamingStyle; + /** + * @generated from field: optional google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility default_symbol_visibility = 8; + */ + defaultSymbolVisibility: FeatureSet_VisibilityFeature_DefaultSymbolVisibility; +}; +/** + * TODO Enums in C++ gencode (and potentially other languages) are + * not well scoped. This means that each of the feature enums below can clash + * with each other. The short names we've chosen maximize call-site + * readability, but leave us very open to this scenario. A future feature will + * be designed and implemented to handle this, hopefully before we ever hit a + * conflict here. + * + * @generated from message google.protobuf.FeatureSet + */ +export type FeatureSetJson = { + /** + * @generated from field: optional google.protobuf.FeatureSet.FieldPresence field_presence = 1; + */ + fieldPresence?: FeatureSet_FieldPresenceJson; + /** + * @generated from field: optional google.protobuf.FeatureSet.EnumType enum_type = 2; + */ + enumType?: FeatureSet_EnumTypeJson; + /** + * @generated from field: optional google.protobuf.FeatureSet.RepeatedFieldEncoding repeated_field_encoding = 3; + */ + repeatedFieldEncoding?: FeatureSet_RepeatedFieldEncodingJson; + /** + * @generated from field: optional google.protobuf.FeatureSet.Utf8Validation utf8_validation = 4; + */ + utf8Validation?: FeatureSet_Utf8ValidationJson; + /** + * @generated from field: optional google.protobuf.FeatureSet.MessageEncoding message_encoding = 5; + */ + messageEncoding?: FeatureSet_MessageEncodingJson; + /** + * @generated from field: optional google.protobuf.FeatureSet.JsonFormat json_format = 6; + */ + jsonFormat?: FeatureSet_JsonFormatJson; + /** + * @generated from field: optional google.protobuf.FeatureSet.EnforceNamingStyle enforce_naming_style = 7; + */ + enforceNamingStyle?: FeatureSet_EnforceNamingStyleJson; + /** + * @generated from field: optional google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility default_symbol_visibility = 8; + */ + defaultSymbolVisibility?: FeatureSet_VisibilityFeature_DefaultSymbolVisibilityJson; +}; +/** + * Describes the message google.protobuf.FeatureSet. + * Use `create(FeatureSetSchema)` to create a new message. + */ +export declare const FeatureSetSchema: GenMessage; +/** + * @generated from message google.protobuf.FeatureSet.VisibilityFeature + */ +export type FeatureSet_VisibilityFeature = Message<"google.protobuf.FeatureSet.VisibilityFeature"> & {}; +/** + * @generated from message google.protobuf.FeatureSet.VisibilityFeature + */ +export type FeatureSet_VisibilityFeatureJson = {}; +/** + * Describes the message google.protobuf.FeatureSet.VisibilityFeature. + * Use `create(FeatureSet_VisibilityFeatureSchema)` to create a new message. + */ +export declare const FeatureSet_VisibilityFeatureSchema: GenMessage; +/** + * @generated from enum google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility + */ +export declare enum FeatureSet_VisibilityFeature_DefaultSymbolVisibility { + /** + * @generated from enum value: DEFAULT_SYMBOL_VISIBILITY_UNKNOWN = 0; + */ + DEFAULT_SYMBOL_VISIBILITY_UNKNOWN = 0, + /** + * Default pre-EDITION_2024, all UNSET visibility are export. + * + * @generated from enum value: EXPORT_ALL = 1; + */ + EXPORT_ALL = 1, + /** + * All top-level symbols default to export, nested default to local. + * + * @generated from enum value: EXPORT_TOP_LEVEL = 2; + */ + EXPORT_TOP_LEVEL = 2, + /** + * All symbols default to local. + * + * @generated from enum value: LOCAL_ALL = 3; + */ + LOCAL_ALL = 3, + /** + * All symbols local by default. Nested types cannot be exported. + * With special case caveat for message { enum {} reserved 1 to max; } + * This is the recommended setting for new protos. + * + * @generated from enum value: STRICT = 4; + */ + STRICT = 4 +} +/** + * @generated from enum google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility + */ +export type FeatureSet_VisibilityFeature_DefaultSymbolVisibilityJson = "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN" | "EXPORT_ALL" | "EXPORT_TOP_LEVEL" | "LOCAL_ALL" | "STRICT"; +/** + * Describes the enum google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility. + */ +export declare const FeatureSet_VisibilityFeature_DefaultSymbolVisibilitySchema: GenEnum; +/** + * @generated from enum google.protobuf.FeatureSet.FieldPresence + */ +export declare enum FeatureSet_FieldPresence { + /** + * @generated from enum value: FIELD_PRESENCE_UNKNOWN = 0; + */ + FIELD_PRESENCE_UNKNOWN = 0, + /** + * @generated from enum value: EXPLICIT = 1; + */ + EXPLICIT = 1, + /** + * @generated from enum value: IMPLICIT = 2; + */ + IMPLICIT = 2, + /** + * @generated from enum value: LEGACY_REQUIRED = 3; + */ + LEGACY_REQUIRED = 3 +} +/** + * @generated from enum google.protobuf.FeatureSet.FieldPresence + */ +export type FeatureSet_FieldPresenceJson = "FIELD_PRESENCE_UNKNOWN" | "EXPLICIT" | "IMPLICIT" | "LEGACY_REQUIRED"; +/** + * Describes the enum google.protobuf.FeatureSet.FieldPresence. + */ +export declare const FeatureSet_FieldPresenceSchema: GenEnum; +/** + * @generated from enum google.protobuf.FeatureSet.EnumType + */ +export declare enum FeatureSet_EnumType { + /** + * @generated from enum value: ENUM_TYPE_UNKNOWN = 0; + */ + ENUM_TYPE_UNKNOWN = 0, + /** + * @generated from enum value: OPEN = 1; + */ + OPEN = 1, + /** + * @generated from enum value: CLOSED = 2; + */ + CLOSED = 2 +} +/** + * @generated from enum google.protobuf.FeatureSet.EnumType + */ +export type FeatureSet_EnumTypeJson = "ENUM_TYPE_UNKNOWN" | "OPEN" | "CLOSED"; +/** + * Describes the enum google.protobuf.FeatureSet.EnumType. + */ +export declare const FeatureSet_EnumTypeSchema: GenEnum; +/** + * @generated from enum google.protobuf.FeatureSet.RepeatedFieldEncoding + */ +export declare enum FeatureSet_RepeatedFieldEncoding { + /** + * @generated from enum value: REPEATED_FIELD_ENCODING_UNKNOWN = 0; + */ + REPEATED_FIELD_ENCODING_UNKNOWN = 0, + /** + * @generated from enum value: PACKED = 1; + */ + PACKED = 1, + /** + * @generated from enum value: EXPANDED = 2; + */ + EXPANDED = 2 +} +/** + * @generated from enum google.protobuf.FeatureSet.RepeatedFieldEncoding + */ +export type FeatureSet_RepeatedFieldEncodingJson = "REPEATED_FIELD_ENCODING_UNKNOWN" | "PACKED" | "EXPANDED"; +/** + * Describes the enum google.protobuf.FeatureSet.RepeatedFieldEncoding. + */ +export declare const FeatureSet_RepeatedFieldEncodingSchema: GenEnum; +/** + * @generated from enum google.protobuf.FeatureSet.Utf8Validation + */ +export declare enum FeatureSet_Utf8Validation { + /** + * @generated from enum value: UTF8_VALIDATION_UNKNOWN = 0; + */ + UTF8_VALIDATION_UNKNOWN = 0, + /** + * @generated from enum value: VERIFY = 2; + */ + VERIFY = 2, + /** + * @generated from enum value: NONE = 3; + */ + NONE = 3 +} +/** + * @generated from enum google.protobuf.FeatureSet.Utf8Validation + */ +export type FeatureSet_Utf8ValidationJson = "UTF8_VALIDATION_UNKNOWN" | "VERIFY" | "NONE"; +/** + * Describes the enum google.protobuf.FeatureSet.Utf8Validation. + */ +export declare const FeatureSet_Utf8ValidationSchema: GenEnum; +/** + * @generated from enum google.protobuf.FeatureSet.MessageEncoding + */ +export declare enum FeatureSet_MessageEncoding { + /** + * @generated from enum value: MESSAGE_ENCODING_UNKNOWN = 0; + */ + MESSAGE_ENCODING_UNKNOWN = 0, + /** + * @generated from enum value: LENGTH_PREFIXED = 1; + */ + LENGTH_PREFIXED = 1, + /** + * @generated from enum value: DELIMITED = 2; + */ + DELIMITED = 2 +} +/** + * @generated from enum google.protobuf.FeatureSet.MessageEncoding + */ +export type FeatureSet_MessageEncodingJson = "MESSAGE_ENCODING_UNKNOWN" | "LENGTH_PREFIXED" | "DELIMITED"; +/** + * Describes the enum google.protobuf.FeatureSet.MessageEncoding. + */ +export declare const FeatureSet_MessageEncodingSchema: GenEnum; +/** + * @generated from enum google.protobuf.FeatureSet.JsonFormat + */ +export declare enum FeatureSet_JsonFormat { + /** + * @generated from enum value: JSON_FORMAT_UNKNOWN = 0; + */ + JSON_FORMAT_UNKNOWN = 0, + /** + * @generated from enum value: ALLOW = 1; + */ + ALLOW = 1, + /** + * @generated from enum value: LEGACY_BEST_EFFORT = 2; + */ + LEGACY_BEST_EFFORT = 2 +} +/** + * @generated from enum google.protobuf.FeatureSet.JsonFormat + */ +export type FeatureSet_JsonFormatJson = "JSON_FORMAT_UNKNOWN" | "ALLOW" | "LEGACY_BEST_EFFORT"; +/** + * Describes the enum google.protobuf.FeatureSet.JsonFormat. + */ +export declare const FeatureSet_JsonFormatSchema: GenEnum; +/** + * @generated from enum google.protobuf.FeatureSet.EnforceNamingStyle + */ +export declare enum FeatureSet_EnforceNamingStyle { + /** + * @generated from enum value: ENFORCE_NAMING_STYLE_UNKNOWN = 0; + */ + ENFORCE_NAMING_STYLE_UNKNOWN = 0, + /** + * @generated from enum value: STYLE2024 = 1; + */ + STYLE2024 = 1, + /** + * @generated from enum value: STYLE_LEGACY = 2; + */ + STYLE_LEGACY = 2 +} +/** + * @generated from enum google.protobuf.FeatureSet.EnforceNamingStyle + */ +export type FeatureSet_EnforceNamingStyleJson = "ENFORCE_NAMING_STYLE_UNKNOWN" | "STYLE2024" | "STYLE_LEGACY"; +/** + * Describes the enum google.protobuf.FeatureSet.EnforceNamingStyle. + */ +export declare const FeatureSet_EnforceNamingStyleSchema: GenEnum; +/** + * A compiled specification for the defaults of a set of features. These + * messages are generated from FeatureSet extensions and can be used to seed + * feature resolution. The resolution with this object becomes a simple search + * for the closest matching edition, followed by proto merges. + * + * @generated from message google.protobuf.FeatureSetDefaults + */ +export type FeatureSetDefaults = Message<"google.protobuf.FeatureSetDefaults"> & { + /** + * @generated from field: repeated google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults = 1; + */ + defaults: FeatureSetDefaults_FeatureSetEditionDefault[]; + /** + * The minimum supported edition (inclusive) when this was constructed. + * Editions before this will not have defaults. + * + * @generated from field: optional google.protobuf.Edition minimum_edition = 4; + */ + minimumEdition: Edition; + /** + * The maximum known edition (inclusive) when this was constructed. Editions + * after this will not have reliable defaults. + * + * @generated from field: optional google.protobuf.Edition maximum_edition = 5; + */ + maximumEdition: Edition; +}; +/** + * A compiled specification for the defaults of a set of features. These + * messages are generated from FeatureSet extensions and can be used to seed + * feature resolution. The resolution with this object becomes a simple search + * for the closest matching edition, followed by proto merges. + * + * @generated from message google.protobuf.FeatureSetDefaults + */ +export type FeatureSetDefaultsJson = { + /** + * @generated from field: repeated google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults = 1; + */ + defaults?: FeatureSetDefaults_FeatureSetEditionDefaultJson[]; + /** + * The minimum supported edition (inclusive) when this was constructed. + * Editions before this will not have defaults. + * + * @generated from field: optional google.protobuf.Edition minimum_edition = 4; + */ + minimumEdition?: EditionJson; + /** + * The maximum known edition (inclusive) when this was constructed. Editions + * after this will not have reliable defaults. + * + * @generated from field: optional google.protobuf.Edition maximum_edition = 5; + */ + maximumEdition?: EditionJson; +}; +/** + * Describes the message google.protobuf.FeatureSetDefaults. + * Use `create(FeatureSetDefaultsSchema)` to create a new message. + */ +export declare const FeatureSetDefaultsSchema: GenMessage; +/** + * A map from every known edition with a unique set of defaults to its + * defaults. Not all editions may be contained here. For a given edition, + * the defaults at the closest matching edition ordered at or before it should + * be used. This field must be in strict ascending order by edition. + * + * @generated from message google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault + */ +export type FeatureSetDefaults_FeatureSetEditionDefault = Message<"google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault"> & { + /** + * @generated from field: optional google.protobuf.Edition edition = 3; + */ + edition: Edition; + /** + * Defaults of features that can be overridden in this edition. + * + * @generated from field: optional google.protobuf.FeatureSet overridable_features = 4; + */ + overridableFeatures?: FeatureSet; + /** + * Defaults of features that can't be overridden in this edition. + * + * @generated from field: optional google.protobuf.FeatureSet fixed_features = 5; + */ + fixedFeatures?: FeatureSet; +}; +/** + * A map from every known edition with a unique set of defaults to its + * defaults. Not all editions may be contained here. For a given edition, + * the defaults at the closest matching edition ordered at or before it should + * be used. This field must be in strict ascending order by edition. + * + * @generated from message google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault + */ +export type FeatureSetDefaults_FeatureSetEditionDefaultJson = { + /** + * @generated from field: optional google.protobuf.Edition edition = 3; + */ + edition?: EditionJson; + /** + * Defaults of features that can be overridden in this edition. + * + * @generated from field: optional google.protobuf.FeatureSet overridable_features = 4; + */ + overridableFeatures?: FeatureSetJson; + /** + * Defaults of features that can't be overridden in this edition. + * + * @generated from field: optional google.protobuf.FeatureSet fixed_features = 5; + */ + fixedFeatures?: FeatureSetJson; +}; +/** + * Describes the message google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault. + * Use `create(FeatureSetDefaults_FeatureSetEditionDefaultSchema)` to create a new message. + */ +export declare const FeatureSetDefaults_FeatureSetEditionDefaultSchema: GenMessage; +/** + * Encapsulates information about the original source file from which a + * FileDescriptorProto was generated. + * + * @generated from message google.protobuf.SourceCodeInfo + */ +export type SourceCodeInfo = Message<"google.protobuf.SourceCodeInfo"> & { + /** + * A Location identifies a piece of source code in a .proto file which + * corresponds to a particular definition. This information is intended + * to be useful to IDEs, code indexers, documentation generators, and similar + * tools. + * + * For example, say we have a file like: + * message Foo { + * optional string foo = 1; + * } + * Let's look at just the field definition: + * optional string foo = 1; + * ^ ^^ ^^ ^ ^^^ + * a bc de f ghi + * We have the following locations: + * span path represents + * [a,i) [ 4, 0, 2, 0 ] The whole field definition. + * [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). + * [c,d) [ 4, 0, 2, 0, 5 ] The type (string). + * [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). + * [g,h) [ 4, 0, 2, 0, 3 ] The number (1). + * + * Notes: + * - A location may refer to a repeated field itself (i.e. not to any + * particular index within it). This is used whenever a set of elements are + * logically enclosed in a single code segment. For example, an entire + * extend block (possibly containing multiple extension definitions) will + * have an outer location whose path refers to the "extensions" repeated + * field without an index. + * - Multiple locations may have the same path. This happens when a single + * logical declaration is spread out across multiple places. The most + * obvious example is the "extend" block again -- there may be multiple + * extend blocks in the same scope, each of which will have the same path. + * - A location's span is not always a subset of its parent's span. For + * example, the "extendee" of an extension declaration appears at the + * beginning of the "extend" block and is shared by all extensions within + * the block. + * - Just because a location's span is a subset of some other location's span + * does not mean that it is a descendant. For example, a "group" defines + * both a type and a field in a single declaration. Thus, the locations + * corresponding to the type and field and their components will overlap. + * - Code which tries to interpret locations should probably be designed to + * ignore those that it doesn't understand, as more types of locations could + * be recorded in the future. + * + * @generated from field: repeated google.protobuf.SourceCodeInfo.Location location = 1; + */ + location: SourceCodeInfo_Location[]; +}; +/** + * Encapsulates information about the original source file from which a + * FileDescriptorProto was generated. + * + * @generated from message google.protobuf.SourceCodeInfo + */ +export type SourceCodeInfoJson = { + /** + * A Location identifies a piece of source code in a .proto file which + * corresponds to a particular definition. This information is intended + * to be useful to IDEs, code indexers, documentation generators, and similar + * tools. + * + * For example, say we have a file like: + * message Foo { + * optional string foo = 1; + * } + * Let's look at just the field definition: + * optional string foo = 1; + * ^ ^^ ^^ ^ ^^^ + * a bc de f ghi + * We have the following locations: + * span path represents + * [a,i) [ 4, 0, 2, 0 ] The whole field definition. + * [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). + * [c,d) [ 4, 0, 2, 0, 5 ] The type (string). + * [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). + * [g,h) [ 4, 0, 2, 0, 3 ] The number (1). + * + * Notes: + * - A location may refer to a repeated field itself (i.e. not to any + * particular index within it). This is used whenever a set of elements are + * logically enclosed in a single code segment. For example, an entire + * extend block (possibly containing multiple extension definitions) will + * have an outer location whose path refers to the "extensions" repeated + * field without an index. + * - Multiple locations may have the same path. This happens when a single + * logical declaration is spread out across multiple places. The most + * obvious example is the "extend" block again -- there may be multiple + * extend blocks in the same scope, each of which will have the same path. + * - A location's span is not always a subset of its parent's span. For + * example, the "extendee" of an extension declaration appears at the + * beginning of the "extend" block and is shared by all extensions within + * the block. + * - Just because a location's span is a subset of some other location's span + * does not mean that it is a descendant. For example, a "group" defines + * both a type and a field in a single declaration. Thus, the locations + * corresponding to the type and field and their components will overlap. + * - Code which tries to interpret locations should probably be designed to + * ignore those that it doesn't understand, as more types of locations could + * be recorded in the future. + * + * @generated from field: repeated google.protobuf.SourceCodeInfo.Location location = 1; + */ + location?: SourceCodeInfo_LocationJson[]; +}; +/** + * Describes the message google.protobuf.SourceCodeInfo. + * Use `create(SourceCodeInfoSchema)` to create a new message. + */ +export declare const SourceCodeInfoSchema: GenMessage; +/** + * @generated from message google.protobuf.SourceCodeInfo.Location + */ +export type SourceCodeInfo_Location = Message<"google.protobuf.SourceCodeInfo.Location"> & { + /** + * Identifies which part of the FileDescriptorProto was defined at this + * location. + * + * Each element is a field number or an index. They form a path from + * the root FileDescriptorProto to the place where the definition appears. + * For example, this path: + * [ 4, 3, 2, 7, 1 ] + * refers to: + * file.message_type(3) // 4, 3 + * .field(7) // 2, 7 + * .name() // 1 + * This is because FileDescriptorProto.message_type has field number 4: + * repeated DescriptorProto message_type = 4; + * and DescriptorProto.field has field number 2: + * repeated FieldDescriptorProto field = 2; + * and FieldDescriptorProto.name has field number 1: + * optional string name = 1; + * + * Thus, the above path gives the location of a field name. If we removed + * the last element: + * [ 4, 3, 2, 7 ] + * this path refers to the whole field declaration (from the beginning + * of the label to the terminating semicolon). + * + * @generated from field: repeated int32 path = 1 [packed = true]; + */ + path: number[]; + /** + * Always has exactly three or four elements: start line, start column, + * end line (optional, otherwise assumed same as start line), end column. + * These are packed into a single field for efficiency. Note that line + * and column numbers are zero-based -- typically you will want to add + * 1 to each before displaying to a user. + * + * @generated from field: repeated int32 span = 2 [packed = true]; + */ + span: number[]; + /** + * If this SourceCodeInfo represents a complete declaration, these are any + * comments appearing before and after the declaration which appear to be + * attached to the declaration. + * + * A series of line comments appearing on consecutive lines, with no other + * tokens appearing on those lines, will be treated as a single comment. + * + * leading_detached_comments will keep paragraphs of comments that appear + * before (but not connected to) the current element. Each paragraph, + * separated by empty lines, will be one comment element in the repeated + * field. + * + * Only the comment content is provided; comment markers (e.g. //) are + * stripped out. For block comments, leading whitespace and an asterisk + * will be stripped from the beginning of each line other than the first. + * Newlines are included in the output. + * + * Examples: + * + * optional int32 foo = 1; // Comment attached to foo. + * // Comment attached to bar. + * optional int32 bar = 2; + * + * optional string baz = 3; + * // Comment attached to baz. + * // Another line attached to baz. + * + * // Comment attached to moo. + * // + * // Another line attached to moo. + * optional double moo = 4; + * + * // Detached comment for corge. This is not leading or trailing comments + * // to moo or corge because there are blank lines separating it from + * // both. + * + * // Detached comment for corge paragraph 2. + * + * optional string corge = 5; + * /* Block comment attached + * * to corge. Leading asterisks + * * will be removed. *\/ + * /* Block comment attached to + * * grault. *\/ + * optional int32 grault = 6; + * + * // ignored detached comments. + * + * @generated from field: optional string leading_comments = 3; + */ + leadingComments: string; + /** + * @generated from field: optional string trailing_comments = 4; + */ + trailingComments: string; + /** + * @generated from field: repeated string leading_detached_comments = 6; + */ + leadingDetachedComments: string[]; +}; +/** + * @generated from message google.protobuf.SourceCodeInfo.Location + */ +export type SourceCodeInfo_LocationJson = { + /** + * Identifies which part of the FileDescriptorProto was defined at this + * location. + * + * Each element is a field number or an index. They form a path from + * the root FileDescriptorProto to the place where the definition appears. + * For example, this path: + * [ 4, 3, 2, 7, 1 ] + * refers to: + * file.message_type(3) // 4, 3 + * .field(7) // 2, 7 + * .name() // 1 + * This is because FileDescriptorProto.message_type has field number 4: + * repeated DescriptorProto message_type = 4; + * and DescriptorProto.field has field number 2: + * repeated FieldDescriptorProto field = 2; + * and FieldDescriptorProto.name has field number 1: + * optional string name = 1; + * + * Thus, the above path gives the location of a field name. If we removed + * the last element: + * [ 4, 3, 2, 7 ] + * this path refers to the whole field declaration (from the beginning + * of the label to the terminating semicolon). + * + * @generated from field: repeated int32 path = 1 [packed = true]; + */ + path?: number[]; + /** + * Always has exactly three or four elements: start line, start column, + * end line (optional, otherwise assumed same as start line), end column. + * These are packed into a single field for efficiency. Note that line + * and column numbers are zero-based -- typically you will want to add + * 1 to each before displaying to a user. + * + * @generated from field: repeated int32 span = 2 [packed = true]; + */ + span?: number[]; + /** + * If this SourceCodeInfo represents a complete declaration, these are any + * comments appearing before and after the declaration which appear to be + * attached to the declaration. + * + * A series of line comments appearing on consecutive lines, with no other + * tokens appearing on those lines, will be treated as a single comment. + * + * leading_detached_comments will keep paragraphs of comments that appear + * before (but not connected to) the current element. Each paragraph, + * separated by empty lines, will be one comment element in the repeated + * field. + * + * Only the comment content is provided; comment markers (e.g. //) are + * stripped out. For block comments, leading whitespace and an asterisk + * will be stripped from the beginning of each line other than the first. + * Newlines are included in the output. + * + * Examples: + * + * optional int32 foo = 1; // Comment attached to foo. + * // Comment attached to bar. + * optional int32 bar = 2; + * + * optional string baz = 3; + * // Comment attached to baz. + * // Another line attached to baz. + * + * // Comment attached to moo. + * // + * // Another line attached to moo. + * optional double moo = 4; + * + * // Detached comment for corge. This is not leading or trailing comments + * // to moo or corge because there are blank lines separating it from + * // both. + * + * // Detached comment for corge paragraph 2. + * + * optional string corge = 5; + * /* Block comment attached + * * to corge. Leading asterisks + * * will be removed. *\/ + * /* Block comment attached to + * * grault. *\/ + * optional int32 grault = 6; + * + * // ignored detached comments. + * + * @generated from field: optional string leading_comments = 3; + */ + leadingComments?: string; + /** + * @generated from field: optional string trailing_comments = 4; + */ + trailingComments?: string; + /** + * @generated from field: repeated string leading_detached_comments = 6; + */ + leadingDetachedComments?: string[]; +}; +/** + * Describes the message google.protobuf.SourceCodeInfo.Location. + * Use `create(SourceCodeInfo_LocationSchema)` to create a new message. + */ +export declare const SourceCodeInfo_LocationSchema: GenMessage; +/** + * Describes the relationship between generated code and its original source + * file. A GeneratedCodeInfo message is associated with only one generated + * source file, but may contain references to different source .proto files. + * + * @generated from message google.protobuf.GeneratedCodeInfo + */ +export type GeneratedCodeInfo = Message<"google.protobuf.GeneratedCodeInfo"> & { + /** + * An Annotation connects some span of text in generated code to an element + * of its generating .proto file. + * + * @generated from field: repeated google.protobuf.GeneratedCodeInfo.Annotation annotation = 1; + */ + annotation: GeneratedCodeInfo_Annotation[]; +}; +/** + * Describes the relationship between generated code and its original source + * file. A GeneratedCodeInfo message is associated with only one generated + * source file, but may contain references to different source .proto files. + * + * @generated from message google.protobuf.GeneratedCodeInfo + */ +export type GeneratedCodeInfoJson = { + /** + * An Annotation connects some span of text in generated code to an element + * of its generating .proto file. + * + * @generated from field: repeated google.protobuf.GeneratedCodeInfo.Annotation annotation = 1; + */ + annotation?: GeneratedCodeInfo_AnnotationJson[]; +}; +/** + * Describes the message google.protobuf.GeneratedCodeInfo. + * Use `create(GeneratedCodeInfoSchema)` to create a new message. + */ +export declare const GeneratedCodeInfoSchema: GenMessage; +/** + * @generated from message google.protobuf.GeneratedCodeInfo.Annotation + */ +export type GeneratedCodeInfo_Annotation = Message<"google.protobuf.GeneratedCodeInfo.Annotation"> & { + /** + * Identifies the element in the original source .proto file. This field + * is formatted the same as SourceCodeInfo.Location.path. + * + * @generated from field: repeated int32 path = 1 [packed = true]; + */ + path: number[]; + /** + * Identifies the filesystem path to the original source .proto. + * + * @generated from field: optional string source_file = 2; + */ + sourceFile: string; + /** + * Identifies the starting offset in bytes in the generated code + * that relates to the identified object. + * + * @generated from field: optional int32 begin = 3; + */ + begin: number; + /** + * Identifies the ending offset in bytes in the generated code that + * relates to the identified object. The end offset should be one past + * the last relevant byte (so the length of the text = end - begin). + * + * @generated from field: optional int32 end = 4; + */ + end: number; + /** + * @generated from field: optional google.protobuf.GeneratedCodeInfo.Annotation.Semantic semantic = 5; + */ + semantic: GeneratedCodeInfo_Annotation_Semantic; +}; +/** + * @generated from message google.protobuf.GeneratedCodeInfo.Annotation + */ +export type GeneratedCodeInfo_AnnotationJson = { + /** + * Identifies the element in the original source .proto file. This field + * is formatted the same as SourceCodeInfo.Location.path. + * + * @generated from field: repeated int32 path = 1 [packed = true]; + */ + path?: number[]; + /** + * Identifies the filesystem path to the original source .proto. + * + * @generated from field: optional string source_file = 2; + */ + sourceFile?: string; + /** + * Identifies the starting offset in bytes in the generated code + * that relates to the identified object. + * + * @generated from field: optional int32 begin = 3; + */ + begin?: number; + /** + * Identifies the ending offset in bytes in the generated code that + * relates to the identified object. The end offset should be one past + * the last relevant byte (so the length of the text = end - begin). + * + * @generated from field: optional int32 end = 4; + */ + end?: number; + /** + * @generated from field: optional google.protobuf.GeneratedCodeInfo.Annotation.Semantic semantic = 5; + */ + semantic?: GeneratedCodeInfo_Annotation_SemanticJson; +}; +/** + * Describes the message google.protobuf.GeneratedCodeInfo.Annotation. + * Use `create(GeneratedCodeInfo_AnnotationSchema)` to create a new message. + */ +export declare const GeneratedCodeInfo_AnnotationSchema: GenMessage; +/** + * Represents the identified object's effect on the element in the original + * .proto file. + * + * @generated from enum google.protobuf.GeneratedCodeInfo.Annotation.Semantic + */ +export declare enum GeneratedCodeInfo_Annotation_Semantic { + /** + * There is no effect or the effect is indescribable. + * + * @generated from enum value: NONE = 0; + */ + NONE = 0, + /** + * The element is set or otherwise mutated. + * + * @generated from enum value: SET = 1; + */ + SET = 1, + /** + * An alias to the element is returned. + * + * @generated from enum value: ALIAS = 2; + */ + ALIAS = 2 +} +/** + * Represents the identified object's effect on the element in the original + * .proto file. + * + * @generated from enum google.protobuf.GeneratedCodeInfo.Annotation.Semantic + */ +export type GeneratedCodeInfo_Annotation_SemanticJson = "NONE" | "SET" | "ALIAS"; +/** + * Describes the enum google.protobuf.GeneratedCodeInfo.Annotation.Semantic. + */ +export declare const GeneratedCodeInfo_Annotation_SemanticSchema: GenEnum; +/** + * The full set of known editions. + * + * @generated from enum google.protobuf.Edition + */ +export declare enum Edition { + /** + * A placeholder for an unknown edition value. + * + * @generated from enum value: EDITION_UNKNOWN = 0; + */ + EDITION_UNKNOWN = 0, + /** + * A placeholder edition for specifying default behaviors *before* a feature + * was first introduced. This is effectively an "infinite past". + * + * @generated from enum value: EDITION_LEGACY = 900; + */ + EDITION_LEGACY = 900, + /** + * Legacy syntax "editions". These pre-date editions, but behave much like + * distinct editions. These can't be used to specify the edition of proto + * files, but feature definitions must supply proto2/proto3 defaults for + * backwards compatibility. + * + * @generated from enum value: EDITION_PROTO2 = 998; + */ + EDITION_PROTO2 = 998, + /** + * @generated from enum value: EDITION_PROTO3 = 999; + */ + EDITION_PROTO3 = 999, + /** + * Editions that have been released. The specific values are arbitrary and + * should not be depended on, but they will always be time-ordered for easy + * comparison. + * + * @generated from enum value: EDITION_2023 = 1000; + */ + EDITION_2023 = 1000, + /** + * @generated from enum value: EDITION_2024 = 1001; + */ + EDITION_2024 = 1001, + /** + * Placeholder editions for testing feature resolution. These should not be + * used or relied on outside of tests. + * + * @generated from enum value: EDITION_1_TEST_ONLY = 1; + */ + EDITION_1_TEST_ONLY = 1, + /** + * @generated from enum value: EDITION_2_TEST_ONLY = 2; + */ + EDITION_2_TEST_ONLY = 2, + /** + * @generated from enum value: EDITION_99997_TEST_ONLY = 99997; + */ + EDITION_99997_TEST_ONLY = 99997, + /** + * @generated from enum value: EDITION_99998_TEST_ONLY = 99998; + */ + EDITION_99998_TEST_ONLY = 99998, + /** + * @generated from enum value: EDITION_99999_TEST_ONLY = 99999; + */ + EDITION_99999_TEST_ONLY = 99999, + /** + * Placeholder for specifying unbounded edition support. This should only + * ever be used by plugins that can expect to never require any changes to + * support a new edition. + * + * @generated from enum value: EDITION_MAX = 2147483647; + */ + EDITION_MAX = 2147483647 +} +/** + * The full set of known editions. + * + * @generated from enum google.protobuf.Edition + */ +export type EditionJson = "EDITION_UNKNOWN" | "EDITION_LEGACY" | "EDITION_PROTO2" | "EDITION_PROTO3" | "EDITION_2023" | "EDITION_2024" | "EDITION_1_TEST_ONLY" | "EDITION_2_TEST_ONLY" | "EDITION_99997_TEST_ONLY" | "EDITION_99998_TEST_ONLY" | "EDITION_99999_TEST_ONLY" | "EDITION_MAX"; +/** + * Describes the enum google.protobuf.Edition. + */ +export declare const EditionSchema: GenEnum; +/** + * Describes the 'visibility' of a symbol with respect to the proto import + * system. Symbols can only be imported when the visibility rules do not prevent + * it (ex: local symbols cannot be imported). Visibility modifiers can only set + * on `message` and `enum` as they are the only types available to be referenced + * from other files. + * + * @generated from enum google.protobuf.SymbolVisibility + */ +export declare enum SymbolVisibility { + /** + * @generated from enum value: VISIBILITY_UNSET = 0; + */ + VISIBILITY_UNSET = 0, + /** + * @generated from enum value: VISIBILITY_LOCAL = 1; + */ + VISIBILITY_LOCAL = 1, + /** + * @generated from enum value: VISIBILITY_EXPORT = 2; + */ + VISIBILITY_EXPORT = 2 +} +/** + * Describes the 'visibility' of a symbol with respect to the proto import + * system. Symbols can only be imported when the visibility rules do not prevent + * it (ex: local symbols cannot be imported). Visibility modifiers can only set + * on `message` and `enum` as they are the only types available to be referenced + * from other files. + * + * @generated from enum google.protobuf.SymbolVisibility + */ +export type SymbolVisibilityJson = "VISIBILITY_UNSET" | "VISIBILITY_LOCAL" | "VISIBILITY_EXPORT"; +/** + * Describes the enum google.protobuf.SymbolVisibility. + */ +export declare const SymbolVisibilitySchema: GenEnum; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/descriptor_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/descriptor_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..f27b75ca5987bcf455f7e3e3abda2e4c3ce45e85 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/descriptor_pb.js @@ -0,0 +1,886 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.FeatureSet_FieldPresence = exports.FeatureSet_VisibilityFeature_DefaultSymbolVisibilitySchema = exports.FeatureSet_VisibilityFeature_DefaultSymbolVisibility = exports.FeatureSet_VisibilityFeatureSchema = exports.FeatureSetSchema = exports.UninterpretedOption_NamePartSchema = exports.UninterpretedOptionSchema = exports.MethodOptions_IdempotencyLevelSchema = exports.MethodOptions_IdempotencyLevel = exports.MethodOptionsSchema = exports.ServiceOptionsSchema = exports.EnumValueOptionsSchema = exports.EnumOptionsSchema = exports.OneofOptionsSchema = exports.FieldOptions_OptionTargetTypeSchema = exports.FieldOptions_OptionTargetType = exports.FieldOptions_OptionRetentionSchema = exports.FieldOptions_OptionRetention = exports.FieldOptions_JSTypeSchema = exports.FieldOptions_JSType = exports.FieldOptions_CTypeSchema = exports.FieldOptions_CType = exports.FieldOptions_FeatureSupportSchema = exports.FieldOptions_EditionDefaultSchema = exports.FieldOptionsSchema = exports.MessageOptionsSchema = exports.FileOptions_OptimizeModeSchema = exports.FileOptions_OptimizeMode = exports.FileOptionsSchema = exports.MethodDescriptorProtoSchema = exports.ServiceDescriptorProtoSchema = exports.EnumValueDescriptorProtoSchema = exports.EnumDescriptorProto_EnumReservedRangeSchema = exports.EnumDescriptorProtoSchema = exports.OneofDescriptorProtoSchema = exports.FieldDescriptorProto_LabelSchema = exports.FieldDescriptorProto_Label = exports.FieldDescriptorProto_TypeSchema = exports.FieldDescriptorProto_Type = exports.FieldDescriptorProtoSchema = exports.ExtensionRangeOptions_VerificationStateSchema = exports.ExtensionRangeOptions_VerificationState = exports.ExtensionRangeOptions_DeclarationSchema = exports.ExtensionRangeOptionsSchema = exports.DescriptorProto_ReservedRangeSchema = exports.DescriptorProto_ExtensionRangeSchema = exports.DescriptorProtoSchema = exports.FileDescriptorProtoSchema = exports.FileDescriptorSetSchema = exports.file_google_protobuf_descriptor = void 0; +exports.SymbolVisibilitySchema = exports.SymbolVisibility = exports.EditionSchema = exports.Edition = exports.GeneratedCodeInfo_Annotation_SemanticSchema = exports.GeneratedCodeInfo_Annotation_Semantic = exports.GeneratedCodeInfo_AnnotationSchema = exports.GeneratedCodeInfoSchema = exports.SourceCodeInfo_LocationSchema = exports.SourceCodeInfoSchema = exports.FeatureSetDefaults_FeatureSetEditionDefaultSchema = exports.FeatureSetDefaultsSchema = exports.FeatureSet_EnforceNamingStyleSchema = exports.FeatureSet_EnforceNamingStyle = exports.FeatureSet_JsonFormatSchema = exports.FeatureSet_JsonFormat = exports.FeatureSet_MessageEncodingSchema = exports.FeatureSet_MessageEncoding = exports.FeatureSet_Utf8ValidationSchema = exports.FeatureSet_Utf8Validation = exports.FeatureSet_RepeatedFieldEncodingSchema = exports.FeatureSet_RepeatedFieldEncoding = exports.FeatureSet_EnumTypeSchema = exports.FeatureSet_EnumType = exports.FeatureSet_FieldPresenceSchema = void 0; +const boot_js_1 = require("../../../../codegenv2/boot.js"); +const message_js_1 = require("../../../../codegenv2/message.js"); +const enum_js_1 = require("../../../../codegenv2/enum.js"); +/** + * Describes the file google/protobuf/descriptor.proto. + */ +exports.file_google_protobuf_descriptor = (0, boot_js_1.boot)({ "name": "google/protobuf/descriptor.proto", "package": "google.protobuf", "messageType": [{ "name": "FileDescriptorSet", "field": [{ "name": "file", "number": 1, "type": 11, "label": 3, "typeName": ".google.protobuf.FileDescriptorProto" }], "extensionRange": [{ "start": 536000000, "end": 536000001 }] }, { "name": "FileDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "package", "number": 2, "type": 9, "label": 1 }, { "name": "dependency", "number": 3, "type": 9, "label": 3 }, { "name": "public_dependency", "number": 10, "type": 5, "label": 3 }, { "name": "weak_dependency", "number": 11, "type": 5, "label": 3 }, { "name": "option_dependency", "number": 15, "type": 9, "label": 3 }, { "name": "message_type", "number": 4, "type": 11, "label": 3, "typeName": ".google.protobuf.DescriptorProto" }, { "name": "enum_type", "number": 5, "type": 11, "label": 3, "typeName": ".google.protobuf.EnumDescriptorProto" }, { "name": "service", "number": 6, "type": 11, "label": 3, "typeName": ".google.protobuf.ServiceDescriptorProto" }, { "name": "extension", "number": 7, "type": 11, "label": 3, "typeName": ".google.protobuf.FieldDescriptorProto" }, { "name": "options", "number": 8, "type": 11, "label": 1, "typeName": ".google.protobuf.FileOptions" }, { "name": "source_code_info", "number": 9, "type": 11, "label": 1, "typeName": ".google.protobuf.SourceCodeInfo" }, { "name": "syntax", "number": 12, "type": 9, "label": 1 }, { "name": "edition", "number": 14, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }] }, { "name": "DescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "field", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.FieldDescriptorProto" }, { "name": "extension", "number": 6, "type": 11, "label": 3, "typeName": ".google.protobuf.FieldDescriptorProto" }, { "name": "nested_type", "number": 3, "type": 11, "label": 3, "typeName": ".google.protobuf.DescriptorProto" }, { "name": "enum_type", "number": 4, "type": 11, "label": 3, "typeName": ".google.protobuf.EnumDescriptorProto" }, { "name": "extension_range", "number": 5, "type": 11, "label": 3, "typeName": ".google.protobuf.DescriptorProto.ExtensionRange" }, { "name": "oneof_decl", "number": 8, "type": 11, "label": 3, "typeName": ".google.protobuf.OneofDescriptorProto" }, { "name": "options", "number": 7, "type": 11, "label": 1, "typeName": ".google.protobuf.MessageOptions" }, { "name": "reserved_range", "number": 9, "type": 11, "label": 3, "typeName": ".google.protobuf.DescriptorProto.ReservedRange" }, { "name": "reserved_name", "number": 10, "type": 9, "label": 3 }, { "name": "visibility", "number": 11, "type": 14, "label": 1, "typeName": ".google.protobuf.SymbolVisibility" }], "nestedType": [{ "name": "ExtensionRange", "field": [{ "name": "start", "number": 1, "type": 5, "label": 1 }, { "name": "end", "number": 2, "type": 5, "label": 1 }, { "name": "options", "number": 3, "type": 11, "label": 1, "typeName": ".google.protobuf.ExtensionRangeOptions" }] }, { "name": "ReservedRange", "field": [{ "name": "start", "number": 1, "type": 5, "label": 1 }, { "name": "end", "number": 2, "type": 5, "label": 1 }] }] }, { "name": "ExtensionRangeOptions", "field": [{ "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }, { "name": "declaration", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.ExtensionRangeOptions.Declaration", "options": { "retention": 2 } }, { "name": "features", "number": 50, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "verification", "number": 3, "type": 14, "label": 1, "typeName": ".google.protobuf.ExtensionRangeOptions.VerificationState", "defaultValue": "UNVERIFIED", "options": { "retention": 2 } }], "nestedType": [{ "name": "Declaration", "field": [{ "name": "number", "number": 1, "type": 5, "label": 1 }, { "name": "full_name", "number": 2, "type": 9, "label": 1 }, { "name": "type", "number": 3, "type": 9, "label": 1 }, { "name": "reserved", "number": 5, "type": 8, "label": 1 }, { "name": "repeated", "number": 6, "type": 8, "label": 1 }] }], "enumType": [{ "name": "VerificationState", "value": [{ "name": "DECLARATION", "number": 0 }, { "name": "UNVERIFIED", "number": 1 }] }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "FieldDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "number", "number": 3, "type": 5, "label": 1 }, { "name": "label", "number": 4, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldDescriptorProto.Label" }, { "name": "type", "number": 5, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldDescriptorProto.Type" }, { "name": "type_name", "number": 6, "type": 9, "label": 1 }, { "name": "extendee", "number": 2, "type": 9, "label": 1 }, { "name": "default_value", "number": 7, "type": 9, "label": 1 }, { "name": "oneof_index", "number": 9, "type": 5, "label": 1 }, { "name": "json_name", "number": 10, "type": 9, "label": 1 }, { "name": "options", "number": 8, "type": 11, "label": 1, "typeName": ".google.protobuf.FieldOptions" }, { "name": "proto3_optional", "number": 17, "type": 8, "label": 1 }], "enumType": [{ "name": "Type", "value": [{ "name": "TYPE_DOUBLE", "number": 1 }, { "name": "TYPE_FLOAT", "number": 2 }, { "name": "TYPE_INT64", "number": 3 }, { "name": "TYPE_UINT64", "number": 4 }, { "name": "TYPE_INT32", "number": 5 }, { "name": "TYPE_FIXED64", "number": 6 }, { "name": "TYPE_FIXED32", "number": 7 }, { "name": "TYPE_BOOL", "number": 8 }, { "name": "TYPE_STRING", "number": 9 }, { "name": "TYPE_GROUP", "number": 10 }, { "name": "TYPE_MESSAGE", "number": 11 }, { "name": "TYPE_BYTES", "number": 12 }, { "name": "TYPE_UINT32", "number": 13 }, { "name": "TYPE_ENUM", "number": 14 }, { "name": "TYPE_SFIXED32", "number": 15 }, { "name": "TYPE_SFIXED64", "number": 16 }, { "name": "TYPE_SINT32", "number": 17 }, { "name": "TYPE_SINT64", "number": 18 }] }, { "name": "Label", "value": [{ "name": "LABEL_OPTIONAL", "number": 1 }, { "name": "LABEL_REPEATED", "number": 3 }, { "name": "LABEL_REQUIRED", "number": 2 }] }] }, { "name": "OneofDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "options", "number": 2, "type": 11, "label": 1, "typeName": ".google.protobuf.OneofOptions" }] }, { "name": "EnumDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "value", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.EnumValueDescriptorProto" }, { "name": "options", "number": 3, "type": 11, "label": 1, "typeName": ".google.protobuf.EnumOptions" }, { "name": "reserved_range", "number": 4, "type": 11, "label": 3, "typeName": ".google.protobuf.EnumDescriptorProto.EnumReservedRange" }, { "name": "reserved_name", "number": 5, "type": 9, "label": 3 }, { "name": "visibility", "number": 6, "type": 14, "label": 1, "typeName": ".google.protobuf.SymbolVisibility" }], "nestedType": [{ "name": "EnumReservedRange", "field": [{ "name": "start", "number": 1, "type": 5, "label": 1 }, { "name": "end", "number": 2, "type": 5, "label": 1 }] }] }, { "name": "EnumValueDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "number", "number": 2, "type": 5, "label": 1 }, { "name": "options", "number": 3, "type": 11, "label": 1, "typeName": ".google.protobuf.EnumValueOptions" }] }, { "name": "ServiceDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "method", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.MethodDescriptorProto" }, { "name": "options", "number": 3, "type": 11, "label": 1, "typeName": ".google.protobuf.ServiceOptions" }] }, { "name": "MethodDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "input_type", "number": 2, "type": 9, "label": 1 }, { "name": "output_type", "number": 3, "type": 9, "label": 1 }, { "name": "options", "number": 4, "type": 11, "label": 1, "typeName": ".google.protobuf.MethodOptions" }, { "name": "client_streaming", "number": 5, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "server_streaming", "number": 6, "type": 8, "label": 1, "defaultValue": "false" }] }, { "name": "FileOptions", "field": [{ "name": "java_package", "number": 1, "type": 9, "label": 1 }, { "name": "java_outer_classname", "number": 8, "type": 9, "label": 1 }, { "name": "java_multiple_files", "number": 10, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "java_generate_equals_and_hash", "number": 20, "type": 8, "label": 1, "options": { "deprecated": true } }, { "name": "java_string_check_utf8", "number": 27, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "optimize_for", "number": 9, "type": 14, "label": 1, "typeName": ".google.protobuf.FileOptions.OptimizeMode", "defaultValue": "SPEED" }, { "name": "go_package", "number": 11, "type": 9, "label": 1 }, { "name": "cc_generic_services", "number": 16, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "java_generic_services", "number": 17, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "py_generic_services", "number": 18, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "deprecated", "number": 23, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "cc_enable_arenas", "number": 31, "type": 8, "label": 1, "defaultValue": "true" }, { "name": "objc_class_prefix", "number": 36, "type": 9, "label": 1 }, { "name": "csharp_namespace", "number": 37, "type": 9, "label": 1 }, { "name": "swift_prefix", "number": 39, "type": 9, "label": 1 }, { "name": "php_class_prefix", "number": 40, "type": 9, "label": 1 }, { "name": "php_namespace", "number": 41, "type": 9, "label": 1 }, { "name": "php_metadata_namespace", "number": 44, "type": 9, "label": 1 }, { "name": "ruby_package", "number": 45, "type": 9, "label": 1 }, { "name": "features", "number": 50, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "enumType": [{ "name": "OptimizeMode", "value": [{ "name": "SPEED", "number": 1 }, { "name": "CODE_SIZE", "number": 2 }, { "name": "LITE_RUNTIME", "number": 3 }] }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "MessageOptions", "field": [{ "name": "message_set_wire_format", "number": 1, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "no_standard_descriptor_accessor", "number": 2, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "deprecated", "number": 3, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "map_entry", "number": 7, "type": 8, "label": 1 }, { "name": "deprecated_legacy_json_field_conflicts", "number": 11, "type": 8, "label": 1, "options": { "deprecated": true } }, { "name": "features", "number": 12, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "FieldOptions", "field": [{ "name": "ctype", "number": 1, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldOptions.CType", "defaultValue": "STRING" }, { "name": "packed", "number": 2, "type": 8, "label": 1 }, { "name": "jstype", "number": 6, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldOptions.JSType", "defaultValue": "JS_NORMAL" }, { "name": "lazy", "number": 5, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "unverified_lazy", "number": 15, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "deprecated", "number": 3, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "weak", "number": 10, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "debug_redact", "number": 16, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "retention", "number": 17, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldOptions.OptionRetention" }, { "name": "targets", "number": 19, "type": 14, "label": 3, "typeName": ".google.protobuf.FieldOptions.OptionTargetType" }, { "name": "edition_defaults", "number": 20, "type": 11, "label": 3, "typeName": ".google.protobuf.FieldOptions.EditionDefault" }, { "name": "features", "number": 21, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "feature_support", "number": 22, "type": 11, "label": 1, "typeName": ".google.protobuf.FieldOptions.FeatureSupport" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "nestedType": [{ "name": "EditionDefault", "field": [{ "name": "edition", "number": 3, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "value", "number": 2, "type": 9, "label": 1 }] }, { "name": "FeatureSupport", "field": [{ "name": "edition_introduced", "number": 1, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "edition_deprecated", "number": 2, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "deprecation_warning", "number": 3, "type": 9, "label": 1 }, { "name": "edition_removed", "number": 4, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }] }], "enumType": [{ "name": "CType", "value": [{ "name": "STRING", "number": 0 }, { "name": "CORD", "number": 1 }, { "name": "STRING_PIECE", "number": 2 }] }, { "name": "JSType", "value": [{ "name": "JS_NORMAL", "number": 0 }, { "name": "JS_STRING", "number": 1 }, { "name": "JS_NUMBER", "number": 2 }] }, { "name": "OptionRetention", "value": [{ "name": "RETENTION_UNKNOWN", "number": 0 }, { "name": "RETENTION_RUNTIME", "number": 1 }, { "name": "RETENTION_SOURCE", "number": 2 }] }, { "name": "OptionTargetType", "value": [{ "name": "TARGET_TYPE_UNKNOWN", "number": 0 }, { "name": "TARGET_TYPE_FILE", "number": 1 }, { "name": "TARGET_TYPE_EXTENSION_RANGE", "number": 2 }, { "name": "TARGET_TYPE_MESSAGE", "number": 3 }, { "name": "TARGET_TYPE_FIELD", "number": 4 }, { "name": "TARGET_TYPE_ONEOF", "number": 5 }, { "name": "TARGET_TYPE_ENUM", "number": 6 }, { "name": "TARGET_TYPE_ENUM_ENTRY", "number": 7 }, { "name": "TARGET_TYPE_SERVICE", "number": 8 }, { "name": "TARGET_TYPE_METHOD", "number": 9 }] }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "OneofOptions", "field": [{ "name": "features", "number": 1, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "EnumOptions", "field": [{ "name": "allow_alias", "number": 2, "type": 8, "label": 1 }, { "name": "deprecated", "number": 3, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "deprecated_legacy_json_field_conflicts", "number": 6, "type": 8, "label": 1, "options": { "deprecated": true } }, { "name": "features", "number": 7, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "EnumValueOptions", "field": [{ "name": "deprecated", "number": 1, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "features", "number": 2, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "debug_redact", "number": 3, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "feature_support", "number": 4, "type": 11, "label": 1, "typeName": ".google.protobuf.FieldOptions.FeatureSupport" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "ServiceOptions", "field": [{ "name": "features", "number": 34, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "deprecated", "number": 33, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "MethodOptions", "field": [{ "name": "deprecated", "number": 33, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "idempotency_level", "number": 34, "type": 14, "label": 1, "typeName": ".google.protobuf.MethodOptions.IdempotencyLevel", "defaultValue": "IDEMPOTENCY_UNKNOWN" }, { "name": "features", "number": 35, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "enumType": [{ "name": "IdempotencyLevel", "value": [{ "name": "IDEMPOTENCY_UNKNOWN", "number": 0 }, { "name": "NO_SIDE_EFFECTS", "number": 1 }, { "name": "IDEMPOTENT", "number": 2 }] }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "UninterpretedOption", "field": [{ "name": "name", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption.NamePart" }, { "name": "identifier_value", "number": 3, "type": 9, "label": 1 }, { "name": "positive_int_value", "number": 4, "type": 4, "label": 1 }, { "name": "negative_int_value", "number": 5, "type": 3, "label": 1 }, { "name": "double_value", "number": 6, "type": 1, "label": 1 }, { "name": "string_value", "number": 7, "type": 12, "label": 1 }, { "name": "aggregate_value", "number": 8, "type": 9, "label": 1 }], "nestedType": [{ "name": "NamePart", "field": [{ "name": "name_part", "number": 1, "type": 9, "label": 2 }, { "name": "is_extension", "number": 2, "type": 8, "label": 2 }] }] }, { "name": "FeatureSet", "field": [{ "name": "field_presence", "number": 1, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.FieldPresence", "options": { "retention": 1, "targets": [4, 1], "editionDefaults": [{ "value": "EXPLICIT", "edition": 900 }, { "value": "IMPLICIT", "edition": 999 }, { "value": "EXPLICIT", "edition": 1000 }] } }, { "name": "enum_type", "number": 2, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.EnumType", "options": { "retention": 1, "targets": [6, 1], "editionDefaults": [{ "value": "CLOSED", "edition": 900 }, { "value": "OPEN", "edition": 999 }] } }, { "name": "repeated_field_encoding", "number": 3, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.RepeatedFieldEncoding", "options": { "retention": 1, "targets": [4, 1], "editionDefaults": [{ "value": "EXPANDED", "edition": 900 }, { "value": "PACKED", "edition": 999 }] } }, { "name": "utf8_validation", "number": 4, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.Utf8Validation", "options": { "retention": 1, "targets": [4, 1], "editionDefaults": [{ "value": "NONE", "edition": 900 }, { "value": "VERIFY", "edition": 999 }] } }, { "name": "message_encoding", "number": 5, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.MessageEncoding", "options": { "retention": 1, "targets": [4, 1], "editionDefaults": [{ "value": "LENGTH_PREFIXED", "edition": 900 }] } }, { "name": "json_format", "number": 6, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.JsonFormat", "options": { "retention": 1, "targets": [3, 6, 1], "editionDefaults": [{ "value": "LEGACY_BEST_EFFORT", "edition": 900 }, { "value": "ALLOW", "edition": 999 }] } }, { "name": "enforce_naming_style", "number": 7, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.EnforceNamingStyle", "options": { "retention": 2, "targets": [1, 2, 3, 4, 5, 6, 7, 8, 9], "editionDefaults": [{ "value": "STYLE_LEGACY", "edition": 900 }, { "value": "STYLE2024", "edition": 1001 }] } }, { "name": "default_symbol_visibility", "number": 8, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility", "options": { "retention": 2, "targets": [1], "editionDefaults": [{ "value": "EXPORT_ALL", "edition": 900 }, { "value": "EXPORT_TOP_LEVEL", "edition": 1001 }] } }], "nestedType": [{ "name": "VisibilityFeature", "enumType": [{ "name": "DefaultSymbolVisibility", "value": [{ "name": "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN", "number": 0 }, { "name": "EXPORT_ALL", "number": 1 }, { "name": "EXPORT_TOP_LEVEL", "number": 2 }, { "name": "LOCAL_ALL", "number": 3 }, { "name": "STRICT", "number": 4 }] }] }], "enumType": [{ "name": "FieldPresence", "value": [{ "name": "FIELD_PRESENCE_UNKNOWN", "number": 0 }, { "name": "EXPLICIT", "number": 1 }, { "name": "IMPLICIT", "number": 2 }, { "name": "LEGACY_REQUIRED", "number": 3 }] }, { "name": "EnumType", "value": [{ "name": "ENUM_TYPE_UNKNOWN", "number": 0 }, { "name": "OPEN", "number": 1 }, { "name": "CLOSED", "number": 2 }] }, { "name": "RepeatedFieldEncoding", "value": [{ "name": "REPEATED_FIELD_ENCODING_UNKNOWN", "number": 0 }, { "name": "PACKED", "number": 1 }, { "name": "EXPANDED", "number": 2 }] }, { "name": "Utf8Validation", "value": [{ "name": "UTF8_VALIDATION_UNKNOWN", "number": 0 }, { "name": "VERIFY", "number": 2 }, { "name": "NONE", "number": 3 }] }, { "name": "MessageEncoding", "value": [{ "name": "MESSAGE_ENCODING_UNKNOWN", "number": 0 }, { "name": "LENGTH_PREFIXED", "number": 1 }, { "name": "DELIMITED", "number": 2 }] }, { "name": "JsonFormat", "value": [{ "name": "JSON_FORMAT_UNKNOWN", "number": 0 }, { "name": "ALLOW", "number": 1 }, { "name": "LEGACY_BEST_EFFORT", "number": 2 }] }, { "name": "EnforceNamingStyle", "value": [{ "name": "ENFORCE_NAMING_STYLE_UNKNOWN", "number": 0 }, { "name": "STYLE2024", "number": 1 }, { "name": "STYLE_LEGACY", "number": 2 }] }], "extensionRange": [{ "start": 1000, "end": 9995 }, { "start": 9995, "end": 10000 }, { "start": 10000, "end": 10001 }] }, { "name": "FeatureSetDefaults", "field": [{ "name": "defaults", "number": 1, "type": 11, "label": 3, "typeName": ".google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault" }, { "name": "minimum_edition", "number": 4, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "maximum_edition", "number": 5, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }], "nestedType": [{ "name": "FeatureSetEditionDefault", "field": [{ "name": "edition", "number": 3, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "overridable_features", "number": 4, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "fixed_features", "number": 5, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }] }] }, { "name": "SourceCodeInfo", "field": [{ "name": "location", "number": 1, "type": 11, "label": 3, "typeName": ".google.protobuf.SourceCodeInfo.Location" }], "nestedType": [{ "name": "Location", "field": [{ "name": "path", "number": 1, "type": 5, "label": 3, "options": { "packed": true } }, { "name": "span", "number": 2, "type": 5, "label": 3, "options": { "packed": true } }, { "name": "leading_comments", "number": 3, "type": 9, "label": 1 }, { "name": "trailing_comments", "number": 4, "type": 9, "label": 1 }, { "name": "leading_detached_comments", "number": 6, "type": 9, "label": 3 }] }], "extensionRange": [{ "start": 536000000, "end": 536000001 }] }, { "name": "GeneratedCodeInfo", "field": [{ "name": "annotation", "number": 1, "type": 11, "label": 3, "typeName": ".google.protobuf.GeneratedCodeInfo.Annotation" }], "nestedType": [{ "name": "Annotation", "field": [{ "name": "path", "number": 1, "type": 5, "label": 3, "options": { "packed": true } }, { "name": "source_file", "number": 2, "type": 9, "label": 1 }, { "name": "begin", "number": 3, "type": 5, "label": 1 }, { "name": "end", "number": 4, "type": 5, "label": 1 }, { "name": "semantic", "number": 5, "type": 14, "label": 1, "typeName": ".google.protobuf.GeneratedCodeInfo.Annotation.Semantic" }], "enumType": [{ "name": "Semantic", "value": [{ "name": "NONE", "number": 0 }, { "name": "SET", "number": 1 }, { "name": "ALIAS", "number": 2 }] }] }] }], "enumType": [{ "name": "Edition", "value": [{ "name": "EDITION_UNKNOWN", "number": 0 }, { "name": "EDITION_LEGACY", "number": 900 }, { "name": "EDITION_PROTO2", "number": 998 }, { "name": "EDITION_PROTO3", "number": 999 }, { "name": "EDITION_2023", "number": 1000 }, { "name": "EDITION_2024", "number": 1001 }, { "name": "EDITION_1_TEST_ONLY", "number": 1 }, { "name": "EDITION_2_TEST_ONLY", "number": 2 }, { "name": "EDITION_99997_TEST_ONLY", "number": 99997 }, { "name": "EDITION_99998_TEST_ONLY", "number": 99998 }, { "name": "EDITION_99999_TEST_ONLY", "number": 99999 }, { "name": "EDITION_MAX", "number": 2147483647 }] }, { "name": "SymbolVisibility", "value": [{ "name": "VISIBILITY_UNSET", "number": 0 }, { "name": "VISIBILITY_LOCAL", "number": 1 }, { "name": "VISIBILITY_EXPORT", "number": 2 }] }] }); +/** + * Describes the message google.protobuf.FileDescriptorSet. + * Use `create(FileDescriptorSetSchema)` to create a new message. + */ +exports.FileDescriptorSetSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 0); +/** + * Describes the message google.protobuf.FileDescriptorProto. + * Use `create(FileDescriptorProtoSchema)` to create a new message. + */ +exports.FileDescriptorProtoSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 1); +/** + * Describes the message google.protobuf.DescriptorProto. + * Use `create(DescriptorProtoSchema)` to create a new message. + */ +exports.DescriptorProtoSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 2); +/** + * Describes the message google.protobuf.DescriptorProto.ExtensionRange. + * Use `create(DescriptorProto_ExtensionRangeSchema)` to create a new message. + */ +exports.DescriptorProto_ExtensionRangeSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 2, 0); +/** + * Describes the message google.protobuf.DescriptorProto.ReservedRange. + * Use `create(DescriptorProto_ReservedRangeSchema)` to create a new message. + */ +exports.DescriptorProto_ReservedRangeSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 2, 1); +/** + * Describes the message google.protobuf.ExtensionRangeOptions. + * Use `create(ExtensionRangeOptionsSchema)` to create a new message. + */ +exports.ExtensionRangeOptionsSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 3); +/** + * Describes the message google.protobuf.ExtensionRangeOptions.Declaration. + * Use `create(ExtensionRangeOptions_DeclarationSchema)` to create a new message. + */ +exports.ExtensionRangeOptions_DeclarationSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 3, 0); +/** + * The verification state of the extension range. + * + * @generated from enum google.protobuf.ExtensionRangeOptions.VerificationState + */ +var ExtensionRangeOptions_VerificationState; +(function (ExtensionRangeOptions_VerificationState) { + /** + * All the extensions of the range must be declared. + * + * @generated from enum value: DECLARATION = 0; + */ + ExtensionRangeOptions_VerificationState[ExtensionRangeOptions_VerificationState["DECLARATION"] = 0] = "DECLARATION"; + /** + * @generated from enum value: UNVERIFIED = 1; + */ + ExtensionRangeOptions_VerificationState[ExtensionRangeOptions_VerificationState["UNVERIFIED"] = 1] = "UNVERIFIED"; +})(ExtensionRangeOptions_VerificationState || (exports.ExtensionRangeOptions_VerificationState = ExtensionRangeOptions_VerificationState = {})); +/** + * Describes the enum google.protobuf.ExtensionRangeOptions.VerificationState. + */ +exports.ExtensionRangeOptions_VerificationStateSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 3, 0); +/** + * Describes the message google.protobuf.FieldDescriptorProto. + * Use `create(FieldDescriptorProtoSchema)` to create a new message. + */ +exports.FieldDescriptorProtoSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 4); +/** + * @generated from enum google.protobuf.FieldDescriptorProto.Type + */ +var FieldDescriptorProto_Type; +(function (FieldDescriptorProto_Type) { + /** + * 0 is reserved for errors. + * Order is weird for historical reasons. + * + * @generated from enum value: TYPE_DOUBLE = 1; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["DOUBLE"] = 1] = "DOUBLE"; + /** + * @generated from enum value: TYPE_FLOAT = 2; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["FLOAT"] = 2] = "FLOAT"; + /** + * Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + * negative values are likely. + * + * @generated from enum value: TYPE_INT64 = 3; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["INT64"] = 3] = "INT64"; + /** + * @generated from enum value: TYPE_UINT64 = 4; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["UINT64"] = 4] = "UINT64"; + /** + * Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + * negative values are likely. + * + * @generated from enum value: TYPE_INT32 = 5; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["INT32"] = 5] = "INT32"; + /** + * @generated from enum value: TYPE_FIXED64 = 6; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["FIXED64"] = 6] = "FIXED64"; + /** + * @generated from enum value: TYPE_FIXED32 = 7; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["FIXED32"] = 7] = "FIXED32"; + /** + * @generated from enum value: TYPE_BOOL = 8; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["BOOL"] = 8] = "BOOL"; + /** + * @generated from enum value: TYPE_STRING = 9; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["STRING"] = 9] = "STRING"; + /** + * Tag-delimited aggregate. + * Group type is deprecated and not supported after google.protobuf. However, Proto3 + * implementations should still be able to parse the group wire format and + * treat group fields as unknown fields. In Editions, the group wire format + * can be enabled via the `message_encoding` feature. + * + * @generated from enum value: TYPE_GROUP = 10; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["GROUP"] = 10] = "GROUP"; + /** + * Length-delimited aggregate. + * + * @generated from enum value: TYPE_MESSAGE = 11; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["MESSAGE"] = 11] = "MESSAGE"; + /** + * New in version 2. + * + * @generated from enum value: TYPE_BYTES = 12; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["BYTES"] = 12] = "BYTES"; + /** + * @generated from enum value: TYPE_UINT32 = 13; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["UINT32"] = 13] = "UINT32"; + /** + * @generated from enum value: TYPE_ENUM = 14; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["ENUM"] = 14] = "ENUM"; + /** + * @generated from enum value: TYPE_SFIXED32 = 15; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["SFIXED32"] = 15] = "SFIXED32"; + /** + * @generated from enum value: TYPE_SFIXED64 = 16; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["SFIXED64"] = 16] = "SFIXED64"; + /** + * Uses ZigZag encoding. + * + * @generated from enum value: TYPE_SINT32 = 17; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["SINT32"] = 17] = "SINT32"; + /** + * Uses ZigZag encoding. + * + * @generated from enum value: TYPE_SINT64 = 18; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["SINT64"] = 18] = "SINT64"; +})(FieldDescriptorProto_Type || (exports.FieldDescriptorProto_Type = FieldDescriptorProto_Type = {})); +/** + * Describes the enum google.protobuf.FieldDescriptorProto.Type. + */ +exports.FieldDescriptorProto_TypeSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 4, 0); +/** + * @generated from enum google.protobuf.FieldDescriptorProto.Label + */ +var FieldDescriptorProto_Label; +(function (FieldDescriptorProto_Label) { + /** + * 0 is reserved for errors + * + * @generated from enum value: LABEL_OPTIONAL = 1; + */ + FieldDescriptorProto_Label[FieldDescriptorProto_Label["OPTIONAL"] = 1] = "OPTIONAL"; + /** + * @generated from enum value: LABEL_REPEATED = 3; + */ + FieldDescriptorProto_Label[FieldDescriptorProto_Label["REPEATED"] = 3] = "REPEATED"; + /** + * The required label is only allowed in google.protobuf. In proto3 and Editions + * it's explicitly prohibited. In Editions, the `field_presence` feature + * can be used to get this behavior. + * + * @generated from enum value: LABEL_REQUIRED = 2; + */ + FieldDescriptorProto_Label[FieldDescriptorProto_Label["REQUIRED"] = 2] = "REQUIRED"; +})(FieldDescriptorProto_Label || (exports.FieldDescriptorProto_Label = FieldDescriptorProto_Label = {})); +/** + * Describes the enum google.protobuf.FieldDescriptorProto.Label. + */ +exports.FieldDescriptorProto_LabelSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 4, 1); +/** + * Describes the message google.protobuf.OneofDescriptorProto. + * Use `create(OneofDescriptorProtoSchema)` to create a new message. + */ +exports.OneofDescriptorProtoSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 5); +/** + * Describes the message google.protobuf.EnumDescriptorProto. + * Use `create(EnumDescriptorProtoSchema)` to create a new message. + */ +exports.EnumDescriptorProtoSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 6); +/** + * Describes the message google.protobuf.EnumDescriptorProto.EnumReservedRange. + * Use `create(EnumDescriptorProto_EnumReservedRangeSchema)` to create a new message. + */ +exports.EnumDescriptorProto_EnumReservedRangeSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 6, 0); +/** + * Describes the message google.protobuf.EnumValueDescriptorProto. + * Use `create(EnumValueDescriptorProtoSchema)` to create a new message. + */ +exports.EnumValueDescriptorProtoSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 7); +/** + * Describes the message google.protobuf.ServiceDescriptorProto. + * Use `create(ServiceDescriptorProtoSchema)` to create a new message. + */ +exports.ServiceDescriptorProtoSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 8); +/** + * Describes the message google.protobuf.MethodDescriptorProto. + * Use `create(MethodDescriptorProtoSchema)` to create a new message. + */ +exports.MethodDescriptorProtoSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 9); +/** + * Describes the message google.protobuf.FileOptions. + * Use `create(FileOptionsSchema)` to create a new message. + */ +exports.FileOptionsSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 10); +/** + * Generated classes can be optimized for speed or code size. + * + * @generated from enum google.protobuf.FileOptions.OptimizeMode + */ +var FileOptions_OptimizeMode; +(function (FileOptions_OptimizeMode) { + /** + * Generate complete code for parsing, serialization, + * + * @generated from enum value: SPEED = 1; + */ + FileOptions_OptimizeMode[FileOptions_OptimizeMode["SPEED"] = 1] = "SPEED"; + /** + * etc. + * + * Use ReflectionOps to implement these methods. + * + * @generated from enum value: CODE_SIZE = 2; + */ + FileOptions_OptimizeMode[FileOptions_OptimizeMode["CODE_SIZE"] = 2] = "CODE_SIZE"; + /** + * Generate code using MessageLite and the lite runtime. + * + * @generated from enum value: LITE_RUNTIME = 3; + */ + FileOptions_OptimizeMode[FileOptions_OptimizeMode["LITE_RUNTIME"] = 3] = "LITE_RUNTIME"; +})(FileOptions_OptimizeMode || (exports.FileOptions_OptimizeMode = FileOptions_OptimizeMode = {})); +/** + * Describes the enum google.protobuf.FileOptions.OptimizeMode. + */ +exports.FileOptions_OptimizeModeSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 10, 0); +/** + * Describes the message google.protobuf.MessageOptions. + * Use `create(MessageOptionsSchema)` to create a new message. + */ +exports.MessageOptionsSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 11); +/** + * Describes the message google.protobuf.FieldOptions. + * Use `create(FieldOptionsSchema)` to create a new message. + */ +exports.FieldOptionsSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 12); +/** + * Describes the message google.protobuf.FieldOptions.EditionDefault. + * Use `create(FieldOptions_EditionDefaultSchema)` to create a new message. + */ +exports.FieldOptions_EditionDefaultSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 12, 0); +/** + * Describes the message google.protobuf.FieldOptions.FeatureSupport. + * Use `create(FieldOptions_FeatureSupportSchema)` to create a new message. + */ +exports.FieldOptions_FeatureSupportSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 12, 1); +/** + * @generated from enum google.protobuf.FieldOptions.CType + */ +var FieldOptions_CType; +(function (FieldOptions_CType) { + /** + * Default mode. + * + * @generated from enum value: STRING = 0; + */ + FieldOptions_CType[FieldOptions_CType["STRING"] = 0] = "STRING"; + /** + * The option [ctype=CORD] may be applied to a non-repeated field of type + * "bytes". It indicates that in C++, the data should be stored in a Cord + * instead of a string. For very large strings, this may reduce memory + * fragmentation. It may also allow better performance when parsing from a + * Cord, or when parsing with aliasing enabled, as the parsed Cord may then + * alias the original buffer. + * + * @generated from enum value: CORD = 1; + */ + FieldOptions_CType[FieldOptions_CType["CORD"] = 1] = "CORD"; + /** + * @generated from enum value: STRING_PIECE = 2; + */ + FieldOptions_CType[FieldOptions_CType["STRING_PIECE"] = 2] = "STRING_PIECE"; +})(FieldOptions_CType || (exports.FieldOptions_CType = FieldOptions_CType = {})); +/** + * Describes the enum google.protobuf.FieldOptions.CType. + */ +exports.FieldOptions_CTypeSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 12, 0); +/** + * @generated from enum google.protobuf.FieldOptions.JSType + */ +var FieldOptions_JSType; +(function (FieldOptions_JSType) { + /** + * Use the default type. + * + * @generated from enum value: JS_NORMAL = 0; + */ + FieldOptions_JSType[FieldOptions_JSType["JS_NORMAL"] = 0] = "JS_NORMAL"; + /** + * Use JavaScript strings. + * + * @generated from enum value: JS_STRING = 1; + */ + FieldOptions_JSType[FieldOptions_JSType["JS_STRING"] = 1] = "JS_STRING"; + /** + * Use JavaScript numbers. + * + * @generated from enum value: JS_NUMBER = 2; + */ + FieldOptions_JSType[FieldOptions_JSType["JS_NUMBER"] = 2] = "JS_NUMBER"; +})(FieldOptions_JSType || (exports.FieldOptions_JSType = FieldOptions_JSType = {})); +/** + * Describes the enum google.protobuf.FieldOptions.JSType. + */ +exports.FieldOptions_JSTypeSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 12, 1); +/** + * If set to RETENTION_SOURCE, the option will be omitted from the binary. + * + * @generated from enum google.protobuf.FieldOptions.OptionRetention + */ +var FieldOptions_OptionRetention; +(function (FieldOptions_OptionRetention) { + /** + * @generated from enum value: RETENTION_UNKNOWN = 0; + */ + FieldOptions_OptionRetention[FieldOptions_OptionRetention["RETENTION_UNKNOWN"] = 0] = "RETENTION_UNKNOWN"; + /** + * @generated from enum value: RETENTION_RUNTIME = 1; + */ + FieldOptions_OptionRetention[FieldOptions_OptionRetention["RETENTION_RUNTIME"] = 1] = "RETENTION_RUNTIME"; + /** + * @generated from enum value: RETENTION_SOURCE = 2; + */ + FieldOptions_OptionRetention[FieldOptions_OptionRetention["RETENTION_SOURCE"] = 2] = "RETENTION_SOURCE"; +})(FieldOptions_OptionRetention || (exports.FieldOptions_OptionRetention = FieldOptions_OptionRetention = {})); +/** + * Describes the enum google.protobuf.FieldOptions.OptionRetention. + */ +exports.FieldOptions_OptionRetentionSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 12, 2); +/** + * This indicates the types of entities that the field may apply to when used + * as an option. If it is unset, then the field may be freely used as an + * option on any kind of entity. + * + * @generated from enum google.protobuf.FieldOptions.OptionTargetType + */ +var FieldOptions_OptionTargetType; +(function (FieldOptions_OptionTargetType) { + /** + * @generated from enum value: TARGET_TYPE_UNKNOWN = 0; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_UNKNOWN"] = 0] = "TARGET_TYPE_UNKNOWN"; + /** + * @generated from enum value: TARGET_TYPE_FILE = 1; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_FILE"] = 1] = "TARGET_TYPE_FILE"; + /** + * @generated from enum value: TARGET_TYPE_EXTENSION_RANGE = 2; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_EXTENSION_RANGE"] = 2] = "TARGET_TYPE_EXTENSION_RANGE"; + /** + * @generated from enum value: TARGET_TYPE_MESSAGE = 3; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_MESSAGE"] = 3] = "TARGET_TYPE_MESSAGE"; + /** + * @generated from enum value: TARGET_TYPE_FIELD = 4; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_FIELD"] = 4] = "TARGET_TYPE_FIELD"; + /** + * @generated from enum value: TARGET_TYPE_ONEOF = 5; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_ONEOF"] = 5] = "TARGET_TYPE_ONEOF"; + /** + * @generated from enum value: TARGET_TYPE_ENUM = 6; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_ENUM"] = 6] = "TARGET_TYPE_ENUM"; + /** + * @generated from enum value: TARGET_TYPE_ENUM_ENTRY = 7; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_ENUM_ENTRY"] = 7] = "TARGET_TYPE_ENUM_ENTRY"; + /** + * @generated from enum value: TARGET_TYPE_SERVICE = 8; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_SERVICE"] = 8] = "TARGET_TYPE_SERVICE"; + /** + * @generated from enum value: TARGET_TYPE_METHOD = 9; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_METHOD"] = 9] = "TARGET_TYPE_METHOD"; +})(FieldOptions_OptionTargetType || (exports.FieldOptions_OptionTargetType = FieldOptions_OptionTargetType = {})); +/** + * Describes the enum google.protobuf.FieldOptions.OptionTargetType. + */ +exports.FieldOptions_OptionTargetTypeSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 12, 3); +/** + * Describes the message google.protobuf.OneofOptions. + * Use `create(OneofOptionsSchema)` to create a new message. + */ +exports.OneofOptionsSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 13); +/** + * Describes the message google.protobuf.EnumOptions. + * Use `create(EnumOptionsSchema)` to create a new message. + */ +exports.EnumOptionsSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 14); +/** + * Describes the message google.protobuf.EnumValueOptions. + * Use `create(EnumValueOptionsSchema)` to create a new message. + */ +exports.EnumValueOptionsSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 15); +/** + * Describes the message google.protobuf.ServiceOptions. + * Use `create(ServiceOptionsSchema)` to create a new message. + */ +exports.ServiceOptionsSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 16); +/** + * Describes the message google.protobuf.MethodOptions. + * Use `create(MethodOptionsSchema)` to create a new message. + */ +exports.MethodOptionsSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 17); +/** + * Is this method side-effect-free (or safe in HTTP parlance), or idempotent, + * or neither? HTTP based RPC implementation may choose GET verb for safe + * methods, and PUT verb for idempotent methods instead of the default POST. + * + * @generated from enum google.protobuf.MethodOptions.IdempotencyLevel + */ +var MethodOptions_IdempotencyLevel; +(function (MethodOptions_IdempotencyLevel) { + /** + * @generated from enum value: IDEMPOTENCY_UNKNOWN = 0; + */ + MethodOptions_IdempotencyLevel[MethodOptions_IdempotencyLevel["IDEMPOTENCY_UNKNOWN"] = 0] = "IDEMPOTENCY_UNKNOWN"; + /** + * implies idempotent + * + * @generated from enum value: NO_SIDE_EFFECTS = 1; + */ + MethodOptions_IdempotencyLevel[MethodOptions_IdempotencyLevel["NO_SIDE_EFFECTS"] = 1] = "NO_SIDE_EFFECTS"; + /** + * idempotent, but may have side effects + * + * @generated from enum value: IDEMPOTENT = 2; + */ + MethodOptions_IdempotencyLevel[MethodOptions_IdempotencyLevel["IDEMPOTENT"] = 2] = "IDEMPOTENT"; +})(MethodOptions_IdempotencyLevel || (exports.MethodOptions_IdempotencyLevel = MethodOptions_IdempotencyLevel = {})); +/** + * Describes the enum google.protobuf.MethodOptions.IdempotencyLevel. + */ +exports.MethodOptions_IdempotencyLevelSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 17, 0); +/** + * Describes the message google.protobuf.UninterpretedOption. + * Use `create(UninterpretedOptionSchema)` to create a new message. + */ +exports.UninterpretedOptionSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 18); +/** + * Describes the message google.protobuf.UninterpretedOption.NamePart. + * Use `create(UninterpretedOption_NamePartSchema)` to create a new message. + */ +exports.UninterpretedOption_NamePartSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 18, 0); +/** + * Describes the message google.protobuf.FeatureSet. + * Use `create(FeatureSetSchema)` to create a new message. + */ +exports.FeatureSetSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 19); +/** + * Describes the message google.protobuf.FeatureSet.VisibilityFeature. + * Use `create(FeatureSet_VisibilityFeatureSchema)` to create a new message. + */ +exports.FeatureSet_VisibilityFeatureSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 19, 0); +/** + * @generated from enum google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility + */ +var FeatureSet_VisibilityFeature_DefaultSymbolVisibility; +(function (FeatureSet_VisibilityFeature_DefaultSymbolVisibility) { + /** + * @generated from enum value: DEFAULT_SYMBOL_VISIBILITY_UNKNOWN = 0; + */ + FeatureSet_VisibilityFeature_DefaultSymbolVisibility[FeatureSet_VisibilityFeature_DefaultSymbolVisibility["DEFAULT_SYMBOL_VISIBILITY_UNKNOWN"] = 0] = "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN"; + /** + * Default pre-EDITION_2024, all UNSET visibility are export. + * + * @generated from enum value: EXPORT_ALL = 1; + */ + FeatureSet_VisibilityFeature_DefaultSymbolVisibility[FeatureSet_VisibilityFeature_DefaultSymbolVisibility["EXPORT_ALL"] = 1] = "EXPORT_ALL"; + /** + * All top-level symbols default to export, nested default to local. + * + * @generated from enum value: EXPORT_TOP_LEVEL = 2; + */ + FeatureSet_VisibilityFeature_DefaultSymbolVisibility[FeatureSet_VisibilityFeature_DefaultSymbolVisibility["EXPORT_TOP_LEVEL"] = 2] = "EXPORT_TOP_LEVEL"; + /** + * All symbols default to local. + * + * @generated from enum value: LOCAL_ALL = 3; + */ + FeatureSet_VisibilityFeature_DefaultSymbolVisibility[FeatureSet_VisibilityFeature_DefaultSymbolVisibility["LOCAL_ALL"] = 3] = "LOCAL_ALL"; + /** + * All symbols local by default. Nested types cannot be exported. + * With special case caveat for message { enum {} reserved 1 to max; } + * This is the recommended setting for new protos. + * + * @generated from enum value: STRICT = 4; + */ + FeatureSet_VisibilityFeature_DefaultSymbolVisibility[FeatureSet_VisibilityFeature_DefaultSymbolVisibility["STRICT"] = 4] = "STRICT"; +})(FeatureSet_VisibilityFeature_DefaultSymbolVisibility || (exports.FeatureSet_VisibilityFeature_DefaultSymbolVisibility = FeatureSet_VisibilityFeature_DefaultSymbolVisibility = {})); +/** + * Describes the enum google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility. + */ +exports.FeatureSet_VisibilityFeature_DefaultSymbolVisibilitySchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 19, 0, 0); +/** + * @generated from enum google.protobuf.FeatureSet.FieldPresence + */ +var FeatureSet_FieldPresence; +(function (FeatureSet_FieldPresence) { + /** + * @generated from enum value: FIELD_PRESENCE_UNKNOWN = 0; + */ + FeatureSet_FieldPresence[FeatureSet_FieldPresence["FIELD_PRESENCE_UNKNOWN"] = 0] = "FIELD_PRESENCE_UNKNOWN"; + /** + * @generated from enum value: EXPLICIT = 1; + */ + FeatureSet_FieldPresence[FeatureSet_FieldPresence["EXPLICIT"] = 1] = "EXPLICIT"; + /** + * @generated from enum value: IMPLICIT = 2; + */ + FeatureSet_FieldPresence[FeatureSet_FieldPresence["IMPLICIT"] = 2] = "IMPLICIT"; + /** + * @generated from enum value: LEGACY_REQUIRED = 3; + */ + FeatureSet_FieldPresence[FeatureSet_FieldPresence["LEGACY_REQUIRED"] = 3] = "LEGACY_REQUIRED"; +})(FeatureSet_FieldPresence || (exports.FeatureSet_FieldPresence = FeatureSet_FieldPresence = {})); +/** + * Describes the enum google.protobuf.FeatureSet.FieldPresence. + */ +exports.FeatureSet_FieldPresenceSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 19, 0); +/** + * @generated from enum google.protobuf.FeatureSet.EnumType + */ +var FeatureSet_EnumType; +(function (FeatureSet_EnumType) { + /** + * @generated from enum value: ENUM_TYPE_UNKNOWN = 0; + */ + FeatureSet_EnumType[FeatureSet_EnumType["ENUM_TYPE_UNKNOWN"] = 0] = "ENUM_TYPE_UNKNOWN"; + /** + * @generated from enum value: OPEN = 1; + */ + FeatureSet_EnumType[FeatureSet_EnumType["OPEN"] = 1] = "OPEN"; + /** + * @generated from enum value: CLOSED = 2; + */ + FeatureSet_EnumType[FeatureSet_EnumType["CLOSED"] = 2] = "CLOSED"; +})(FeatureSet_EnumType || (exports.FeatureSet_EnumType = FeatureSet_EnumType = {})); +/** + * Describes the enum google.protobuf.FeatureSet.EnumType. + */ +exports.FeatureSet_EnumTypeSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 19, 1); +/** + * @generated from enum google.protobuf.FeatureSet.RepeatedFieldEncoding + */ +var FeatureSet_RepeatedFieldEncoding; +(function (FeatureSet_RepeatedFieldEncoding) { + /** + * @generated from enum value: REPEATED_FIELD_ENCODING_UNKNOWN = 0; + */ + FeatureSet_RepeatedFieldEncoding[FeatureSet_RepeatedFieldEncoding["REPEATED_FIELD_ENCODING_UNKNOWN"] = 0] = "REPEATED_FIELD_ENCODING_UNKNOWN"; + /** + * @generated from enum value: PACKED = 1; + */ + FeatureSet_RepeatedFieldEncoding[FeatureSet_RepeatedFieldEncoding["PACKED"] = 1] = "PACKED"; + /** + * @generated from enum value: EXPANDED = 2; + */ + FeatureSet_RepeatedFieldEncoding[FeatureSet_RepeatedFieldEncoding["EXPANDED"] = 2] = "EXPANDED"; +})(FeatureSet_RepeatedFieldEncoding || (exports.FeatureSet_RepeatedFieldEncoding = FeatureSet_RepeatedFieldEncoding = {})); +/** + * Describes the enum google.protobuf.FeatureSet.RepeatedFieldEncoding. + */ +exports.FeatureSet_RepeatedFieldEncodingSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 19, 2); +/** + * @generated from enum google.protobuf.FeatureSet.Utf8Validation + */ +var FeatureSet_Utf8Validation; +(function (FeatureSet_Utf8Validation) { + /** + * @generated from enum value: UTF8_VALIDATION_UNKNOWN = 0; + */ + FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["UTF8_VALIDATION_UNKNOWN"] = 0] = "UTF8_VALIDATION_UNKNOWN"; + /** + * @generated from enum value: VERIFY = 2; + */ + FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["VERIFY"] = 2] = "VERIFY"; + /** + * @generated from enum value: NONE = 3; + */ + FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["NONE"] = 3] = "NONE"; +})(FeatureSet_Utf8Validation || (exports.FeatureSet_Utf8Validation = FeatureSet_Utf8Validation = {})); +/** + * Describes the enum google.protobuf.FeatureSet.Utf8Validation. + */ +exports.FeatureSet_Utf8ValidationSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 19, 3); +/** + * @generated from enum google.protobuf.FeatureSet.MessageEncoding + */ +var FeatureSet_MessageEncoding; +(function (FeatureSet_MessageEncoding) { + /** + * @generated from enum value: MESSAGE_ENCODING_UNKNOWN = 0; + */ + FeatureSet_MessageEncoding[FeatureSet_MessageEncoding["MESSAGE_ENCODING_UNKNOWN"] = 0] = "MESSAGE_ENCODING_UNKNOWN"; + /** + * @generated from enum value: LENGTH_PREFIXED = 1; + */ + FeatureSet_MessageEncoding[FeatureSet_MessageEncoding["LENGTH_PREFIXED"] = 1] = "LENGTH_PREFIXED"; + /** + * @generated from enum value: DELIMITED = 2; + */ + FeatureSet_MessageEncoding[FeatureSet_MessageEncoding["DELIMITED"] = 2] = "DELIMITED"; +})(FeatureSet_MessageEncoding || (exports.FeatureSet_MessageEncoding = FeatureSet_MessageEncoding = {})); +/** + * Describes the enum google.protobuf.FeatureSet.MessageEncoding. + */ +exports.FeatureSet_MessageEncodingSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 19, 4); +/** + * @generated from enum google.protobuf.FeatureSet.JsonFormat + */ +var FeatureSet_JsonFormat; +(function (FeatureSet_JsonFormat) { + /** + * @generated from enum value: JSON_FORMAT_UNKNOWN = 0; + */ + FeatureSet_JsonFormat[FeatureSet_JsonFormat["JSON_FORMAT_UNKNOWN"] = 0] = "JSON_FORMAT_UNKNOWN"; + /** + * @generated from enum value: ALLOW = 1; + */ + FeatureSet_JsonFormat[FeatureSet_JsonFormat["ALLOW"] = 1] = "ALLOW"; + /** + * @generated from enum value: LEGACY_BEST_EFFORT = 2; + */ + FeatureSet_JsonFormat[FeatureSet_JsonFormat["LEGACY_BEST_EFFORT"] = 2] = "LEGACY_BEST_EFFORT"; +})(FeatureSet_JsonFormat || (exports.FeatureSet_JsonFormat = FeatureSet_JsonFormat = {})); +/** + * Describes the enum google.protobuf.FeatureSet.JsonFormat. + */ +exports.FeatureSet_JsonFormatSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 19, 5); +/** + * @generated from enum google.protobuf.FeatureSet.EnforceNamingStyle + */ +var FeatureSet_EnforceNamingStyle; +(function (FeatureSet_EnforceNamingStyle) { + /** + * @generated from enum value: ENFORCE_NAMING_STYLE_UNKNOWN = 0; + */ + FeatureSet_EnforceNamingStyle[FeatureSet_EnforceNamingStyle["ENFORCE_NAMING_STYLE_UNKNOWN"] = 0] = "ENFORCE_NAMING_STYLE_UNKNOWN"; + /** + * @generated from enum value: STYLE2024 = 1; + */ + FeatureSet_EnforceNamingStyle[FeatureSet_EnforceNamingStyle["STYLE2024"] = 1] = "STYLE2024"; + /** + * @generated from enum value: STYLE_LEGACY = 2; + */ + FeatureSet_EnforceNamingStyle[FeatureSet_EnforceNamingStyle["STYLE_LEGACY"] = 2] = "STYLE_LEGACY"; +})(FeatureSet_EnforceNamingStyle || (exports.FeatureSet_EnforceNamingStyle = FeatureSet_EnforceNamingStyle = {})); +/** + * Describes the enum google.protobuf.FeatureSet.EnforceNamingStyle. + */ +exports.FeatureSet_EnforceNamingStyleSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 19, 6); +/** + * Describes the message google.protobuf.FeatureSetDefaults. + * Use `create(FeatureSetDefaultsSchema)` to create a new message. + */ +exports.FeatureSetDefaultsSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 20); +/** + * Describes the message google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault. + * Use `create(FeatureSetDefaults_FeatureSetEditionDefaultSchema)` to create a new message. + */ +exports.FeatureSetDefaults_FeatureSetEditionDefaultSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 20, 0); +/** + * Describes the message google.protobuf.SourceCodeInfo. + * Use `create(SourceCodeInfoSchema)` to create a new message. + */ +exports.SourceCodeInfoSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 21); +/** + * Describes the message google.protobuf.SourceCodeInfo.Location. + * Use `create(SourceCodeInfo_LocationSchema)` to create a new message. + */ +exports.SourceCodeInfo_LocationSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 21, 0); +/** + * Describes the message google.protobuf.GeneratedCodeInfo. + * Use `create(GeneratedCodeInfoSchema)` to create a new message. + */ +exports.GeneratedCodeInfoSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 22); +/** + * Describes the message google.protobuf.GeneratedCodeInfo.Annotation. + * Use `create(GeneratedCodeInfo_AnnotationSchema)` to create a new message. + */ +exports.GeneratedCodeInfo_AnnotationSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_descriptor, 22, 0); +/** + * Represents the identified object's effect on the element in the original + * .proto file. + * + * @generated from enum google.protobuf.GeneratedCodeInfo.Annotation.Semantic + */ +var GeneratedCodeInfo_Annotation_Semantic; +(function (GeneratedCodeInfo_Annotation_Semantic) { + /** + * There is no effect or the effect is indescribable. + * + * @generated from enum value: NONE = 0; + */ + GeneratedCodeInfo_Annotation_Semantic[GeneratedCodeInfo_Annotation_Semantic["NONE"] = 0] = "NONE"; + /** + * The element is set or otherwise mutated. + * + * @generated from enum value: SET = 1; + */ + GeneratedCodeInfo_Annotation_Semantic[GeneratedCodeInfo_Annotation_Semantic["SET"] = 1] = "SET"; + /** + * An alias to the element is returned. + * + * @generated from enum value: ALIAS = 2; + */ + GeneratedCodeInfo_Annotation_Semantic[GeneratedCodeInfo_Annotation_Semantic["ALIAS"] = 2] = "ALIAS"; +})(GeneratedCodeInfo_Annotation_Semantic || (exports.GeneratedCodeInfo_Annotation_Semantic = GeneratedCodeInfo_Annotation_Semantic = {})); +/** + * Describes the enum google.protobuf.GeneratedCodeInfo.Annotation.Semantic. + */ +exports.GeneratedCodeInfo_Annotation_SemanticSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 22, 0, 0); +/** + * The full set of known editions. + * + * @generated from enum google.protobuf.Edition + */ +var Edition; +(function (Edition) { + /** + * A placeholder for an unknown edition value. + * + * @generated from enum value: EDITION_UNKNOWN = 0; + */ + Edition[Edition["EDITION_UNKNOWN"] = 0] = "EDITION_UNKNOWN"; + /** + * A placeholder edition for specifying default behaviors *before* a feature + * was first introduced. This is effectively an "infinite past". + * + * @generated from enum value: EDITION_LEGACY = 900; + */ + Edition[Edition["EDITION_LEGACY"] = 900] = "EDITION_LEGACY"; + /** + * Legacy syntax "editions". These pre-date editions, but behave much like + * distinct editions. These can't be used to specify the edition of proto + * files, but feature definitions must supply proto2/proto3 defaults for + * backwards compatibility. + * + * @generated from enum value: EDITION_PROTO2 = 998; + */ + Edition[Edition["EDITION_PROTO2"] = 998] = "EDITION_PROTO2"; + /** + * @generated from enum value: EDITION_PROTO3 = 999; + */ + Edition[Edition["EDITION_PROTO3"] = 999] = "EDITION_PROTO3"; + /** + * Editions that have been released. The specific values are arbitrary and + * should not be depended on, but they will always be time-ordered for easy + * comparison. + * + * @generated from enum value: EDITION_2023 = 1000; + */ + Edition[Edition["EDITION_2023"] = 1000] = "EDITION_2023"; + /** + * @generated from enum value: EDITION_2024 = 1001; + */ + Edition[Edition["EDITION_2024"] = 1001] = "EDITION_2024"; + /** + * Placeholder editions for testing feature resolution. These should not be + * used or relied on outside of tests. + * + * @generated from enum value: EDITION_1_TEST_ONLY = 1; + */ + Edition[Edition["EDITION_1_TEST_ONLY"] = 1] = "EDITION_1_TEST_ONLY"; + /** + * @generated from enum value: EDITION_2_TEST_ONLY = 2; + */ + Edition[Edition["EDITION_2_TEST_ONLY"] = 2] = "EDITION_2_TEST_ONLY"; + /** + * @generated from enum value: EDITION_99997_TEST_ONLY = 99997; + */ + Edition[Edition["EDITION_99997_TEST_ONLY"] = 99997] = "EDITION_99997_TEST_ONLY"; + /** + * @generated from enum value: EDITION_99998_TEST_ONLY = 99998; + */ + Edition[Edition["EDITION_99998_TEST_ONLY"] = 99998] = "EDITION_99998_TEST_ONLY"; + /** + * @generated from enum value: EDITION_99999_TEST_ONLY = 99999; + */ + Edition[Edition["EDITION_99999_TEST_ONLY"] = 99999] = "EDITION_99999_TEST_ONLY"; + /** + * Placeholder for specifying unbounded edition support. This should only + * ever be used by plugins that can expect to never require any changes to + * support a new edition. + * + * @generated from enum value: EDITION_MAX = 2147483647; + */ + Edition[Edition["EDITION_MAX"] = 2147483647] = "EDITION_MAX"; +})(Edition || (exports.Edition = Edition = {})); +/** + * Describes the enum google.protobuf.Edition. + */ +exports.EditionSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 0); +/** + * Describes the 'visibility' of a symbol with respect to the proto import + * system. Symbols can only be imported when the visibility rules do not prevent + * it (ex: local symbols cannot be imported). Visibility modifiers can only set + * on `message` and `enum` as they are the only types available to be referenced + * from other files. + * + * @generated from enum google.protobuf.SymbolVisibility + */ +var SymbolVisibility; +(function (SymbolVisibility) { + /** + * @generated from enum value: VISIBILITY_UNSET = 0; + */ + SymbolVisibility[SymbolVisibility["VISIBILITY_UNSET"] = 0] = "VISIBILITY_UNSET"; + /** + * @generated from enum value: VISIBILITY_LOCAL = 1; + */ + SymbolVisibility[SymbolVisibility["VISIBILITY_LOCAL"] = 1] = "VISIBILITY_LOCAL"; + /** + * @generated from enum value: VISIBILITY_EXPORT = 2; + */ + SymbolVisibility[SymbolVisibility["VISIBILITY_EXPORT"] = 2] = "VISIBILITY_EXPORT"; +})(SymbolVisibility || (exports.SymbolVisibility = SymbolVisibility = {})); +/** + * Describes the enum google.protobuf.SymbolVisibility. + */ +exports.SymbolVisibilitySchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_descriptor, 1); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/duration_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/duration_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a779ebf2c3ea59b8969fa97663a6a7ecb5c29cb2 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/duration_pb.d.ts @@ -0,0 +1,161 @@ +import type { GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/duration.proto. + */ +export declare const file_google_protobuf_duration: GenFile; +/** + * A Duration represents a signed, fixed-length span of time represented + * as a count of seconds and fractions of seconds at nanosecond + * resolution. It is independent of any calendar and concepts like "day" + * or "month". It is related to Timestamp in that the difference between + * two Timestamp values is a Duration and it can be added or subtracted + * from a Timestamp. Range is approximately +-10,000 years. + * + * # Examples + * + * Example 1: Compute Duration from two Timestamps in pseudo code. + * + * Timestamp start = ...; + * Timestamp end = ...; + * Duration duration = ...; + * + * duration.seconds = end.seconds - start.seconds; + * duration.nanos = end.nanos - start.nanos; + * + * if (duration.seconds < 0 && duration.nanos > 0) { + * duration.seconds += 1; + * duration.nanos -= 1000000000; + * } else if (duration.seconds > 0 && duration.nanos < 0) { + * duration.seconds -= 1; + * duration.nanos += 1000000000; + * } + * + * Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. + * + * Timestamp start = ...; + * Duration duration = ...; + * Timestamp end = ...; + * + * end.seconds = start.seconds + duration.seconds; + * end.nanos = start.nanos + duration.nanos; + * + * if (end.nanos < 0) { + * end.seconds -= 1; + * end.nanos += 1000000000; + * } else if (end.nanos >= 1000000000) { + * end.seconds += 1; + * end.nanos -= 1000000000; + * } + * + * Example 3: Compute Duration from datetime.timedelta in Python. + * + * td = datetime.timedelta(days=3, minutes=10) + * duration = Duration() + * duration.FromTimedelta(td) + * + * # JSON Mapping + * + * In JSON format, the Duration type is encoded as a string rather than an + * object, where the string ends in the suffix "s" (indicating seconds) and + * is preceded by the number of seconds, with nanoseconds expressed as + * fractional seconds. For example, 3 seconds with 0 nanoseconds should be + * encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should + * be expressed in JSON format as "3.000000001s", and 3 seconds and 1 + * microsecond should be expressed in JSON format as "3.000001s". + * + * + * @generated from message google.protobuf.Duration + */ +export type Duration = Message<"google.protobuf.Duration"> & { + /** + * Signed seconds of the span of time. Must be from -315,576,000,000 + * to +315,576,000,000 inclusive. Note: these bounds are computed from: + * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years + * + * @generated from field: int64 seconds = 1; + */ + seconds: bigint; + /** + * Signed fractions of a second at nanosecond resolution of the span + * of time. Durations less than one second are represented with a 0 + * `seconds` field and a positive or negative `nanos` field. For durations + * of one second or more, a non-zero value for the `nanos` field must be + * of the same sign as the `seconds` field. Must be from -999,999,999 + * to +999,999,999 inclusive. + * + * @generated from field: int32 nanos = 2; + */ + nanos: number; +}; +/** + * A Duration represents a signed, fixed-length span of time represented + * as a count of seconds and fractions of seconds at nanosecond + * resolution. It is independent of any calendar and concepts like "day" + * or "month". It is related to Timestamp in that the difference between + * two Timestamp values is a Duration and it can be added or subtracted + * from a Timestamp. Range is approximately +-10,000 years. + * + * # Examples + * + * Example 1: Compute Duration from two Timestamps in pseudo code. + * + * Timestamp start = ...; + * Timestamp end = ...; + * Duration duration = ...; + * + * duration.seconds = end.seconds - start.seconds; + * duration.nanos = end.nanos - start.nanos; + * + * if (duration.seconds < 0 && duration.nanos > 0) { + * duration.seconds += 1; + * duration.nanos -= 1000000000; + * } else if (duration.seconds > 0 && duration.nanos < 0) { + * duration.seconds -= 1; + * duration.nanos += 1000000000; + * } + * + * Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. + * + * Timestamp start = ...; + * Duration duration = ...; + * Timestamp end = ...; + * + * end.seconds = start.seconds + duration.seconds; + * end.nanos = start.nanos + duration.nanos; + * + * if (end.nanos < 0) { + * end.seconds -= 1; + * end.nanos += 1000000000; + * } else if (end.nanos >= 1000000000) { + * end.seconds += 1; + * end.nanos -= 1000000000; + * } + * + * Example 3: Compute Duration from datetime.timedelta in Python. + * + * td = datetime.timedelta(days=3, minutes=10) + * duration = Duration() + * duration.FromTimedelta(td) + * + * # JSON Mapping + * + * In JSON format, the Duration type is encoded as a string rather than an + * object, where the string ends in the suffix "s" (indicating seconds) and + * is preceded by the number of seconds, with nanoseconds expressed as + * fractional seconds. For example, 3 seconds with 0 nanoseconds should be + * encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should + * be expressed in JSON format as "3.000000001s", and 3 seconds and 1 + * microsecond should be expressed in JSON format as "3.000001s". + * + * + * @generated from message google.protobuf.Duration + */ +export type DurationJson = string; +/** + * Describes the message google.protobuf.Duration. + * Use `create(DurationSchema)` to create a new message. + */ +export declare const DurationSchema: GenMessage; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/duration_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/duration_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..5d32362990da05b1b21c02945d94a4e896345e01 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/duration_pb.js @@ -0,0 +1,27 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.DurationSchema = exports.file_google_protobuf_duration = void 0; +const file_js_1 = require("../../../../codegenv2/file.js"); +const message_js_1 = require("../../../../codegenv2/message.js"); +/** + * Describes the file google/protobuf/duration.proto. + */ +exports.file_google_protobuf_duration = (0, file_js_1.fileDesc)("Ch5nb29nbGUvcHJvdG9idWYvZHVyYXRpb24ucHJvdG8SD2dvb2dsZS5wcm90b2J1ZiIqCghEdXJhdGlvbhIPCgdzZWNvbmRzGAEgASgDEg0KBW5hbm9zGAIgASgFQoMBChNjb20uZ29vZ2xlLnByb3RvYnVmQg1EdXJhdGlvblByb3RvUAFaMWdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL2R1cmF0aW9ucGL4AQGiAgNHUEKqAh5Hb29nbGUuUHJvdG9idWYuV2VsbEtub3duVHlwZXNiBnByb3RvMw"); +/** + * Describes the message google.protobuf.Duration. + * Use `create(DurationSchema)` to create a new message. + */ +exports.DurationSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_duration, 0); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/empty_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/empty_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d53d5685903c494b674b3be7695d804a95759523 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/empty_pb.d.ts @@ -0,0 +1,39 @@ +import type { GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/empty.proto. + */ +export declare const file_google_protobuf_empty: GenFile; +/** + * A generic empty message that you can re-use to avoid defining duplicated + * empty messages in your APIs. A typical example is to use it as the request + * or the response type of an API method. For instance: + * + * service Foo { + * rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); + * } + * + * + * @generated from message google.protobuf.Empty + */ +export type Empty = Message<"google.protobuf.Empty"> & {}; +/** + * A generic empty message that you can re-use to avoid defining duplicated + * empty messages in your APIs. A typical example is to use it as the request + * or the response type of an API method. For instance: + * + * service Foo { + * rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); + * } + * + * + * @generated from message google.protobuf.Empty + */ +export type EmptyJson = Record; +/** + * Describes the message google.protobuf.Empty. + * Use `create(EmptySchema)` to create a new message. + */ +export declare const EmptySchema: GenMessage; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/empty_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/empty_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..99bb6621b4df758a58cfc85887e8d33c61c02664 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/empty_pb.js @@ -0,0 +1,27 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.EmptySchema = exports.file_google_protobuf_empty = void 0; +const file_js_1 = require("../../../../codegenv2/file.js"); +const message_js_1 = require("../../../../codegenv2/message.js"); +/** + * Describes the file google/protobuf/empty.proto. + */ +exports.file_google_protobuf_empty = (0, file_js_1.fileDesc)("Chtnb29nbGUvcHJvdG9idWYvZW1wdHkucHJvdG8SD2dvb2dsZS5wcm90b2J1ZiIHCgVFbXB0eUJ9ChNjb20uZ29vZ2xlLnByb3RvYnVmQgpFbXB0eVByb3RvUAFaLmdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL2VtcHR5cGL4AQGiAgNHUEKqAh5Hb29nbGUuUHJvdG9idWYuV2VsbEtub3duVHlwZXNiBnByb3RvMw"); +/** + * Describes the message google.protobuf.Empty. + * Use `create(EmptySchema)` to create a new message. + */ +exports.EmptySchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_empty, 0); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/field_mask_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/field_mask_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..31781f3947e51a1912177cd2863d04cdfd9ea391 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/field_mask_pb.d.ts @@ -0,0 +1,428 @@ +import type { GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/field_mask.proto. + */ +export declare const file_google_protobuf_field_mask: GenFile; +/** + * `FieldMask` represents a set of symbolic field paths, for example: + * + * paths: "f.a" + * paths: "f.b.d" + * + * Here `f` represents a field in some root message, `a` and `b` + * fields in the message found in `f`, and `d` a field found in the + * message in `f.b`. + * + * Field masks are used to specify a subset of fields that should be + * returned by a get operation or modified by an update operation. + * Field masks also have a custom JSON encoding (see below). + * + * # Field Masks in Projections + * + * When used in the context of a projection, a response message or + * sub-message is filtered by the API to only contain those fields as + * specified in the mask. For example, if the mask in the previous + * example is applied to a response message as follows: + * + * f { + * a : 22 + * b { + * d : 1 + * x : 2 + * } + * y : 13 + * } + * z: 8 + * + * The result will not contain specific values for fields x,y and z + * (their value will be set to the default, and omitted in proto text + * output): + * + * + * f { + * a : 22 + * b { + * d : 1 + * } + * } + * + * A repeated field is not allowed except at the last position of a + * paths string. + * + * If a FieldMask object is not present in a get operation, the + * operation applies to all fields (as if a FieldMask of all fields + * had been specified). + * + * Note that a field mask does not necessarily apply to the + * top-level response message. In case of a REST get operation, the + * field mask applies directly to the response, but in case of a REST + * list operation, the mask instead applies to each individual message + * in the returned resource list. In case of a REST custom method, + * other definitions may be used. Where the mask applies will be + * clearly documented together with its declaration in the API. In + * any case, the effect on the returned resource/resources is required + * behavior for APIs. + * + * # Field Masks in Update Operations + * + * A field mask in update operations specifies which fields of the + * targeted resource are going to be updated. The API is required + * to only change the values of the fields as specified in the mask + * and leave the others untouched. If a resource is passed in to + * describe the updated values, the API ignores the values of all + * fields not covered by the mask. + * + * If a repeated field is specified for an update operation, new values will + * be appended to the existing repeated field in the target resource. Note that + * a repeated field is only allowed in the last position of a `paths` string. + * + * If a sub-message is specified in the last position of the field mask for an + * update operation, then new value will be merged into the existing sub-message + * in the target resource. + * + * For example, given the target message: + * + * f { + * b { + * d: 1 + * x: 2 + * } + * c: [1] + * } + * + * And an update message: + * + * f { + * b { + * d: 10 + * } + * c: [2] + * } + * + * then if the field mask is: + * + * paths: ["f.b", "f.c"] + * + * then the result will be: + * + * f { + * b { + * d: 10 + * x: 2 + * } + * c: [1, 2] + * } + * + * An implementation may provide options to override this default behavior for + * repeated and message fields. + * + * In order to reset a field's value to the default, the field must + * be in the mask and set to the default value in the provided resource. + * Hence, in order to reset all fields of a resource, provide a default + * instance of the resource and set all fields in the mask, or do + * not provide a mask as described below. + * + * If a field mask is not present on update, the operation applies to + * all fields (as if a field mask of all fields has been specified). + * Note that in the presence of schema evolution, this may mean that + * fields the client does not know and has therefore not filled into + * the request will be reset to their default. If this is unwanted + * behavior, a specific service may require a client to always specify + * a field mask, producing an error if not. + * + * As with get operations, the location of the resource which + * describes the updated values in the request message depends on the + * operation kind. In any case, the effect of the field mask is + * required to be honored by the API. + * + * ## Considerations for HTTP REST + * + * The HTTP kind of an update operation which uses a field mask must + * be set to PATCH instead of PUT in order to satisfy HTTP semantics + * (PUT must only be used for full updates). + * + * # JSON Encoding of Field Masks + * + * In JSON, a field mask is encoded as a single string where paths are + * separated by a comma. Fields name in each path are converted + * to/from lower-camel naming conventions. + * + * As an example, consider the following message declarations: + * + * message Profile { + * User user = 1; + * Photo photo = 2; + * } + * message User { + * string display_name = 1; + * string address = 2; + * } + * + * In proto a field mask for `Profile` may look as such: + * + * mask { + * paths: "user.display_name" + * paths: "photo" + * } + * + * In JSON, the same mask is represented as below: + * + * { + * mask: "user.displayName,photo" + * } + * + * # Field Masks and Oneof Fields + * + * Field masks treat fields in oneofs just as regular fields. Consider the + * following message: + * + * message SampleMessage { + * oneof test_oneof { + * string name = 4; + * SubMessage sub_message = 9; + * } + * } + * + * The field mask can be: + * + * mask { + * paths: "name" + * } + * + * Or: + * + * mask { + * paths: "sub_message" + * } + * + * Note that oneof type names ("test_oneof" in this case) cannot be used in + * paths. + * + * ## Field Mask Verification + * + * The implementation of any API method which has a FieldMask type field in the + * request should verify the included field paths, and return an + * `INVALID_ARGUMENT` error if any path is unmappable. + * + * @generated from message google.protobuf.FieldMask + */ +export type FieldMask = Message<"google.protobuf.FieldMask"> & { + /** + * The set of field mask paths. + * + * @generated from field: repeated string paths = 1; + */ + paths: string[]; +}; +/** + * `FieldMask` represents a set of symbolic field paths, for example: + * + * paths: "f.a" + * paths: "f.b.d" + * + * Here `f` represents a field in some root message, `a` and `b` + * fields in the message found in `f`, and `d` a field found in the + * message in `f.b`. + * + * Field masks are used to specify a subset of fields that should be + * returned by a get operation or modified by an update operation. + * Field masks also have a custom JSON encoding (see below). + * + * # Field Masks in Projections + * + * When used in the context of a projection, a response message or + * sub-message is filtered by the API to only contain those fields as + * specified in the mask. For example, if the mask in the previous + * example is applied to a response message as follows: + * + * f { + * a : 22 + * b { + * d : 1 + * x : 2 + * } + * y : 13 + * } + * z: 8 + * + * The result will not contain specific values for fields x,y and z + * (their value will be set to the default, and omitted in proto text + * output): + * + * + * f { + * a : 22 + * b { + * d : 1 + * } + * } + * + * A repeated field is not allowed except at the last position of a + * paths string. + * + * If a FieldMask object is not present in a get operation, the + * operation applies to all fields (as if a FieldMask of all fields + * had been specified). + * + * Note that a field mask does not necessarily apply to the + * top-level response message. In case of a REST get operation, the + * field mask applies directly to the response, but in case of a REST + * list operation, the mask instead applies to each individual message + * in the returned resource list. In case of a REST custom method, + * other definitions may be used. Where the mask applies will be + * clearly documented together with its declaration in the API. In + * any case, the effect on the returned resource/resources is required + * behavior for APIs. + * + * # Field Masks in Update Operations + * + * A field mask in update operations specifies which fields of the + * targeted resource are going to be updated. The API is required + * to only change the values of the fields as specified in the mask + * and leave the others untouched. If a resource is passed in to + * describe the updated values, the API ignores the values of all + * fields not covered by the mask. + * + * If a repeated field is specified for an update operation, new values will + * be appended to the existing repeated field in the target resource. Note that + * a repeated field is only allowed in the last position of a `paths` string. + * + * If a sub-message is specified in the last position of the field mask for an + * update operation, then new value will be merged into the existing sub-message + * in the target resource. + * + * For example, given the target message: + * + * f { + * b { + * d: 1 + * x: 2 + * } + * c: [1] + * } + * + * And an update message: + * + * f { + * b { + * d: 10 + * } + * c: [2] + * } + * + * then if the field mask is: + * + * paths: ["f.b", "f.c"] + * + * then the result will be: + * + * f { + * b { + * d: 10 + * x: 2 + * } + * c: [1, 2] + * } + * + * An implementation may provide options to override this default behavior for + * repeated and message fields. + * + * In order to reset a field's value to the default, the field must + * be in the mask and set to the default value in the provided resource. + * Hence, in order to reset all fields of a resource, provide a default + * instance of the resource and set all fields in the mask, or do + * not provide a mask as described below. + * + * If a field mask is not present on update, the operation applies to + * all fields (as if a field mask of all fields has been specified). + * Note that in the presence of schema evolution, this may mean that + * fields the client does not know and has therefore not filled into + * the request will be reset to their default. If this is unwanted + * behavior, a specific service may require a client to always specify + * a field mask, producing an error if not. + * + * As with get operations, the location of the resource which + * describes the updated values in the request message depends on the + * operation kind. In any case, the effect of the field mask is + * required to be honored by the API. + * + * ## Considerations for HTTP REST + * + * The HTTP kind of an update operation which uses a field mask must + * be set to PATCH instead of PUT in order to satisfy HTTP semantics + * (PUT must only be used for full updates). + * + * # JSON Encoding of Field Masks + * + * In JSON, a field mask is encoded as a single string where paths are + * separated by a comma. Fields name in each path are converted + * to/from lower-camel naming conventions. + * + * As an example, consider the following message declarations: + * + * message Profile { + * User user = 1; + * Photo photo = 2; + * } + * message User { + * string display_name = 1; + * string address = 2; + * } + * + * In proto a field mask for `Profile` may look as such: + * + * mask { + * paths: "user.display_name" + * paths: "photo" + * } + * + * In JSON, the same mask is represented as below: + * + * { + * mask: "user.displayName,photo" + * } + * + * # Field Masks and Oneof Fields + * + * Field masks treat fields in oneofs just as regular fields. Consider the + * following message: + * + * message SampleMessage { + * oneof test_oneof { + * string name = 4; + * SubMessage sub_message = 9; + * } + * } + * + * The field mask can be: + * + * mask { + * paths: "name" + * } + * + * Or: + * + * mask { + * paths: "sub_message" + * } + * + * Note that oneof type names ("test_oneof" in this case) cannot be used in + * paths. + * + * ## Field Mask Verification + * + * The implementation of any API method which has a FieldMask type field in the + * request should verify the included field paths, and return an + * `INVALID_ARGUMENT` error if any path is unmappable. + * + * @generated from message google.protobuf.FieldMask + */ +export type FieldMaskJson = string; +/** + * Describes the message google.protobuf.FieldMask. + * Use `create(FieldMaskSchema)` to create a new message. + */ +export declare const FieldMaskSchema: GenMessage; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/field_mask_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/field_mask_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..dbacdbaeecd63b6a9e38d0f790b23631db36a08f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/field_mask_pb.js @@ -0,0 +1,27 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.FieldMaskSchema = exports.file_google_protobuf_field_mask = void 0; +const file_js_1 = require("../../../../codegenv2/file.js"); +const message_js_1 = require("../../../../codegenv2/message.js"); +/** + * Describes the file google/protobuf/field_mask.proto. + */ +exports.file_google_protobuf_field_mask = (0, file_js_1.fileDesc)("CiBnb29nbGUvcHJvdG9idWYvZmllbGRfbWFzay5wcm90bxIPZ29vZ2xlLnByb3RvYnVmIhoKCUZpZWxkTWFzaxINCgVwYXRocxgBIAMoCUKFAQoTY29tLmdvb2dsZS5wcm90b2J1ZkIORmllbGRNYXNrUHJvdG9QAVoyZ29vZ2xlLmdvbGFuZy5vcmcvcHJvdG9idWYvdHlwZXMva25vd24vZmllbGRtYXNrcGL4AQGiAgNHUEKqAh5Hb29nbGUuUHJvdG9idWYuV2VsbEtub3duVHlwZXNiBnByb3RvMw"); +/** + * Describes the message google.protobuf.FieldMask. + * Use `create(FieldMaskSchema)` to create a new message. + */ +exports.FieldMaskSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_field_mask, 0); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/go_features_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/go_features_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8925b9ab31f70ae049cce6906b78b131be76901e --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/go_features_pb.d.ts @@ -0,0 +1,124 @@ +import type { GenEnum, GenExtension, GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { FeatureSet } from "./descriptor_pb.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/go_features.proto. + */ +export declare const file_google_protobuf_go_features: GenFile; +/** + * @generated from message pb.GoFeatures + */ +export type GoFeatures = Message<"pb.GoFeatures"> & { + /** + * Whether or not to generate the deprecated UnmarshalJSON method for enums. + * Can only be true for proto using the Open Struct api. + * + * @generated from field: optional bool legacy_unmarshal_json_enum = 1; + */ + legacyUnmarshalJsonEnum: boolean; + /** + * One of OPEN, HYBRID or OPAQUE. + * + * @generated from field: optional pb.GoFeatures.APILevel api_level = 2; + */ + apiLevel: GoFeatures_APILevel; + /** + * @generated from field: optional pb.GoFeatures.StripEnumPrefix strip_enum_prefix = 3; + */ + stripEnumPrefix: GoFeatures_StripEnumPrefix; +}; +/** + * @generated from message pb.GoFeatures + */ +export type GoFeaturesJson = { + /** + * Whether or not to generate the deprecated UnmarshalJSON method for enums. + * Can only be true for proto using the Open Struct api. + * + * @generated from field: optional bool legacy_unmarshal_json_enum = 1; + */ + legacyUnmarshalJsonEnum?: boolean; + /** + * One of OPEN, HYBRID or OPAQUE. + * + * @generated from field: optional pb.GoFeatures.APILevel api_level = 2; + */ + apiLevel?: GoFeatures_APILevelJson; + /** + * @generated from field: optional pb.GoFeatures.StripEnumPrefix strip_enum_prefix = 3; + */ + stripEnumPrefix?: GoFeatures_StripEnumPrefixJson; +}; +/** + * Describes the message pb.GoFeatures. + * Use `create(GoFeaturesSchema)` to create a new message. + */ +export declare const GoFeaturesSchema: GenMessage; +/** + * @generated from enum pb.GoFeatures.APILevel + */ +export declare enum GoFeatures_APILevel { + /** + * API_LEVEL_UNSPECIFIED results in selecting the OPEN API, + * but needs to be a separate value to distinguish between + * an explicitly set api level or a missing api level. + * + * @generated from enum value: API_LEVEL_UNSPECIFIED = 0; + */ + API_LEVEL_UNSPECIFIED = 0, + /** + * @generated from enum value: API_OPEN = 1; + */ + API_OPEN = 1, + /** + * @generated from enum value: API_HYBRID = 2; + */ + API_HYBRID = 2, + /** + * @generated from enum value: API_OPAQUE = 3; + */ + API_OPAQUE = 3 +} +/** + * @generated from enum pb.GoFeatures.APILevel + */ +export type GoFeatures_APILevelJson = "API_LEVEL_UNSPECIFIED" | "API_OPEN" | "API_HYBRID" | "API_OPAQUE"; +/** + * Describes the enum pb.GoFeatures.APILevel. + */ +export declare const GoFeatures_APILevelSchema: GenEnum; +/** + * @generated from enum pb.GoFeatures.StripEnumPrefix + */ +export declare enum GoFeatures_StripEnumPrefix { + /** + * @generated from enum value: STRIP_ENUM_PREFIX_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + /** + * @generated from enum value: STRIP_ENUM_PREFIX_KEEP = 1; + */ + KEEP = 1, + /** + * @generated from enum value: STRIP_ENUM_PREFIX_GENERATE_BOTH = 2; + */ + GENERATE_BOTH = 2, + /** + * @generated from enum value: STRIP_ENUM_PREFIX_STRIP = 3; + */ + STRIP = 3 +} +/** + * @generated from enum pb.GoFeatures.StripEnumPrefix + */ +export type GoFeatures_StripEnumPrefixJson = "STRIP_ENUM_PREFIX_UNSPECIFIED" | "STRIP_ENUM_PREFIX_KEEP" | "STRIP_ENUM_PREFIX_GENERATE_BOTH" | "STRIP_ENUM_PREFIX_STRIP"; +/** + * Describes the enum pb.GoFeatures.StripEnumPrefix. + */ +export declare const GoFeatures_StripEnumPrefixSchema: GenEnum; +/** + * @generated from extension: optional pb.GoFeatures go = 1002; + */ +export declare const go: GenExtension; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/go_features_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/go_features_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..b9d841e356e4fc4146f8cc90b42b90bd6e89e0e2 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/go_features_pb.js @@ -0,0 +1,90 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.go = exports.GoFeatures_StripEnumPrefixSchema = exports.GoFeatures_StripEnumPrefix = exports.GoFeatures_APILevelSchema = exports.GoFeatures_APILevel = exports.GoFeaturesSchema = exports.file_google_protobuf_go_features = void 0; +const file_js_1 = require("../../../../codegenv2/file.js"); +const descriptor_pb_js_1 = require("./descriptor_pb.js"); +const message_js_1 = require("../../../../codegenv2/message.js"); +const enum_js_1 = require("../../../../codegenv2/enum.js"); +const extension_js_1 = require("../../../../codegenv2/extension.js"); +/** + * Describes the file google/protobuf/go_features.proto. + */ +exports.file_google_protobuf_go_features = (0, file_js_1.fileDesc)("CiFnb29nbGUvcHJvdG9idWYvZ29fZmVhdHVyZXMucHJvdG8SAnBiIvcECgpHb0ZlYXR1cmVzEqUBChpsZWdhY3lfdW5tYXJzaGFsX2pzb25fZW51bRgBIAEoCEKAAYgBAZgBBpgBAaIBCRIEdHJ1ZRiEB6IBChIFZmFsc2UY5weyAVsI6AcQ6AcaU1RoZSBsZWdhY3kgVW5tYXJzaGFsSlNPTiBBUEkgaXMgZGVwcmVjYXRlZCBhbmQgd2lsbCBiZSByZW1vdmVkIGluIGEgZnV0dXJlIGVkaXRpb24uEmoKCWFwaV9sZXZlbBgCIAEoDjIXLnBiLkdvRmVhdHVyZXMuQVBJTGV2ZWxCPogBAZgBA5gBAaIBGhIVQVBJX0xFVkVMX1VOU1BFQ0lGSUVEGIQHogEPEgpBUElfT1BBUVVFGOkHsgEDCOgHEmsKEXN0cmlwX2VudW1fcHJlZml4GAMgASgOMh4ucGIuR29GZWF0dXJlcy5TdHJpcEVudW1QcmVmaXhCMIgBAZgBBpgBB5gBAaIBGxIWU1RSSVBfRU5VTV9QUkVGSVhfS0VFUBiEB7IBAwjpByJTCghBUElMZXZlbBIZChVBUElfTEVWRUxfVU5TUEVDSUZJRUQQABIMCghBUElfT1BFThABEg4KCkFQSV9IWUJSSUQQAhIOCgpBUElfT1BBUVVFEAMikgEKD1N0cmlwRW51bVByZWZpeBIhCh1TVFJJUF9FTlVNX1BSRUZJWF9VTlNQRUNJRklFRBAAEhoKFlNUUklQX0VOVU1fUFJFRklYX0tFRVAQARIjCh9TVFJJUF9FTlVNX1BSRUZJWF9HRU5FUkFURV9CT1RIEAISGwoXU1RSSVBfRU5VTV9QUkVGSVhfU1RSSVAQAzo8CgJnbxIbLmdvb2dsZS5wcm90b2J1Zi5GZWF0dXJlU2V0GOoHIAEoCzIOLnBiLkdvRmVhdHVyZXNSAmdvQi9aLWdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2dvZmVhdHVyZXNwYg", [descriptor_pb_js_1.file_google_protobuf_descriptor]); +/** + * Describes the message pb.GoFeatures. + * Use `create(GoFeaturesSchema)` to create a new message. + */ +exports.GoFeaturesSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_go_features, 0); +/** + * @generated from enum pb.GoFeatures.APILevel + */ +var GoFeatures_APILevel; +(function (GoFeatures_APILevel) { + /** + * API_LEVEL_UNSPECIFIED results in selecting the OPEN API, + * but needs to be a separate value to distinguish between + * an explicitly set api level or a missing api level. + * + * @generated from enum value: API_LEVEL_UNSPECIFIED = 0; + */ + GoFeatures_APILevel[GoFeatures_APILevel["API_LEVEL_UNSPECIFIED"] = 0] = "API_LEVEL_UNSPECIFIED"; + /** + * @generated from enum value: API_OPEN = 1; + */ + GoFeatures_APILevel[GoFeatures_APILevel["API_OPEN"] = 1] = "API_OPEN"; + /** + * @generated from enum value: API_HYBRID = 2; + */ + GoFeatures_APILevel[GoFeatures_APILevel["API_HYBRID"] = 2] = "API_HYBRID"; + /** + * @generated from enum value: API_OPAQUE = 3; + */ + GoFeatures_APILevel[GoFeatures_APILevel["API_OPAQUE"] = 3] = "API_OPAQUE"; +})(GoFeatures_APILevel || (exports.GoFeatures_APILevel = GoFeatures_APILevel = {})); +/** + * Describes the enum pb.GoFeatures.APILevel. + */ +exports.GoFeatures_APILevelSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_go_features, 0, 0); +/** + * @generated from enum pb.GoFeatures.StripEnumPrefix + */ +var GoFeatures_StripEnumPrefix; +(function (GoFeatures_StripEnumPrefix) { + /** + * @generated from enum value: STRIP_ENUM_PREFIX_UNSPECIFIED = 0; + */ + GoFeatures_StripEnumPrefix[GoFeatures_StripEnumPrefix["UNSPECIFIED"] = 0] = "UNSPECIFIED"; + /** + * @generated from enum value: STRIP_ENUM_PREFIX_KEEP = 1; + */ + GoFeatures_StripEnumPrefix[GoFeatures_StripEnumPrefix["KEEP"] = 1] = "KEEP"; + /** + * @generated from enum value: STRIP_ENUM_PREFIX_GENERATE_BOTH = 2; + */ + GoFeatures_StripEnumPrefix[GoFeatures_StripEnumPrefix["GENERATE_BOTH"] = 2] = "GENERATE_BOTH"; + /** + * @generated from enum value: STRIP_ENUM_PREFIX_STRIP = 3; + */ + GoFeatures_StripEnumPrefix[GoFeatures_StripEnumPrefix["STRIP"] = 3] = "STRIP"; +})(GoFeatures_StripEnumPrefix || (exports.GoFeatures_StripEnumPrefix = GoFeatures_StripEnumPrefix = {})); +/** + * Describes the enum pb.GoFeatures.StripEnumPrefix. + */ +exports.GoFeatures_StripEnumPrefixSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_go_features, 0, 1); +/** + * @generated from extension: optional pb.GoFeatures go = 1002; + */ +exports.go = (0, extension_js_1.extDesc)(exports.file_google_protobuf_go_features, 0); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/java_features_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/java_features_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..47f1503e6a15858997f0e9e3415a99e208b6a7ad --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/java_features_pb.d.ts @@ -0,0 +1,194 @@ +import type { GenEnum, GenExtension, GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { FeatureSet } from "./descriptor_pb.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/java_features.proto. + */ +export declare const file_google_protobuf_java_features: GenFile; +/** + * @generated from message pb.JavaFeatures + */ +export type JavaFeatures = Message<"pb.JavaFeatures"> & { + /** + * Whether or not to treat an enum field as closed. This option is only + * applicable to enum fields, and will be removed in the future. It is + * consistent with the legacy behavior of using proto3 enum types for proto2 + * fields. + * + * @generated from field: optional bool legacy_closed_enum = 1; + */ + legacyClosedEnum: boolean; + /** + * @generated from field: optional pb.JavaFeatures.Utf8Validation utf8_validation = 2; + */ + utf8Validation: JavaFeatures_Utf8Validation; + /** + * Allows creation of large Java enums, extending beyond the standard + * constant limits imposed by the Java language. + * + * @generated from field: optional bool large_enum = 3; + */ + largeEnum: boolean; + /** + * Whether to use the old default outer class name scheme, or the new feature + * which adds a "Proto" suffix to the outer class name. + * + * Users will not be able to set this option, because we removed it in the + * same edition that it was introduced. But we use it to determine which + * naming scheme to use for outer class name defaults. + * + * @generated from field: optional bool use_old_outer_classname_default = 4; + */ + useOldOuterClassnameDefault: boolean; + /** + * Whether to nest the generated class in the generated file class. This is + * only applicable to *top-level* messages, enums, and services. + * + * @generated from field: optional pb.JavaFeatures.NestInFileClassFeature.NestInFileClass nest_in_file_class = 5; + */ + nestInFileClass: JavaFeatures_NestInFileClassFeature_NestInFileClass; +}; +/** + * @generated from message pb.JavaFeatures + */ +export type JavaFeaturesJson = { + /** + * Whether or not to treat an enum field as closed. This option is only + * applicable to enum fields, and will be removed in the future. It is + * consistent with the legacy behavior of using proto3 enum types for proto2 + * fields. + * + * @generated from field: optional bool legacy_closed_enum = 1; + */ + legacyClosedEnum?: boolean; + /** + * @generated from field: optional pb.JavaFeatures.Utf8Validation utf8_validation = 2; + */ + utf8Validation?: JavaFeatures_Utf8ValidationJson; + /** + * Allows creation of large Java enums, extending beyond the standard + * constant limits imposed by the Java language. + * + * @generated from field: optional bool large_enum = 3; + */ + largeEnum?: boolean; + /** + * Whether to use the old default outer class name scheme, or the new feature + * which adds a "Proto" suffix to the outer class name. + * + * Users will not be able to set this option, because we removed it in the + * same edition that it was introduced. But we use it to determine which + * naming scheme to use for outer class name defaults. + * + * @generated from field: optional bool use_old_outer_classname_default = 4; + */ + useOldOuterClassnameDefault?: boolean; + /** + * Whether to nest the generated class in the generated file class. This is + * only applicable to *top-level* messages, enums, and services. + * + * @generated from field: optional pb.JavaFeatures.NestInFileClassFeature.NestInFileClass nest_in_file_class = 5; + */ + nestInFileClass?: JavaFeatures_NestInFileClassFeature_NestInFileClassJson; +}; +/** + * Describes the message pb.JavaFeatures. + * Use `create(JavaFeaturesSchema)` to create a new message. + */ +export declare const JavaFeaturesSchema: GenMessage; +/** + * @generated from message pb.JavaFeatures.NestInFileClassFeature + */ +export type JavaFeatures_NestInFileClassFeature = Message<"pb.JavaFeatures.NestInFileClassFeature"> & {}; +/** + * @generated from message pb.JavaFeatures.NestInFileClassFeature + */ +export type JavaFeatures_NestInFileClassFeatureJson = {}; +/** + * Describes the message pb.JavaFeatures.NestInFileClassFeature. + * Use `create(JavaFeatures_NestInFileClassFeatureSchema)` to create a new message. + */ +export declare const JavaFeatures_NestInFileClassFeatureSchema: GenMessage; +/** + * @generated from enum pb.JavaFeatures.NestInFileClassFeature.NestInFileClass + */ +export declare enum JavaFeatures_NestInFileClassFeature_NestInFileClass { + /** + * Invalid default, which should never be used. + * + * @generated from enum value: NEST_IN_FILE_CLASS_UNKNOWN = 0; + */ + NEST_IN_FILE_CLASS_UNKNOWN = 0, + /** + * Do not nest the generated class in the file class. + * + * @generated from enum value: NO = 1; + */ + NO = 1, + /** + * Nest the generated class in the file class. + * + * @generated from enum value: YES = 2; + */ + YES = 2, + /** + * Fall back to the `java_multiple_files` option. Users won't be able to + * set this option. + * + * @generated from enum value: LEGACY = 3; + */ + LEGACY = 3 +} +/** + * @generated from enum pb.JavaFeatures.NestInFileClassFeature.NestInFileClass + */ +export type JavaFeatures_NestInFileClassFeature_NestInFileClassJson = "NEST_IN_FILE_CLASS_UNKNOWN" | "NO" | "YES" | "LEGACY"; +/** + * Describes the enum pb.JavaFeatures.NestInFileClassFeature.NestInFileClass. + */ +export declare const JavaFeatures_NestInFileClassFeature_NestInFileClassSchema: GenEnum; +/** + * The UTF8 validation strategy to use. + * + * @generated from enum pb.JavaFeatures.Utf8Validation + */ +export declare enum JavaFeatures_Utf8Validation { + /** + * Invalid default, which should never be used. + * + * @generated from enum value: UTF8_VALIDATION_UNKNOWN = 0; + */ + UTF8_VALIDATION_UNKNOWN = 0, + /** + * Respect the UTF8 validation behavior specified by the global + * utf8_validation feature. + * + * @generated from enum value: DEFAULT = 1; + */ + DEFAULT = 1, + /** + * Verifies UTF8 validity overriding the global utf8_validation + * feature. This represents the legacy java_string_check_utf8 option. + * + * @generated from enum value: VERIFY = 2; + */ + VERIFY = 2 +} +/** + * The UTF8 validation strategy to use. + * + * @generated from enum pb.JavaFeatures.Utf8Validation + */ +export type JavaFeatures_Utf8ValidationJson = "UTF8_VALIDATION_UNKNOWN" | "DEFAULT" | "VERIFY"; +/** + * Describes the enum pb.JavaFeatures.Utf8Validation. + */ +export declare const JavaFeatures_Utf8ValidationSchema: GenEnum; +/** + * @generated from extension: optional pb.JavaFeatures java = 1001; + */ +export declare const java: GenExtension; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/java_features_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/java_features_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..ddf14cc7b3a614fed4910aa255b1237538c87b3b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/java_features_pb.js @@ -0,0 +1,106 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.java = exports.JavaFeatures_Utf8ValidationSchema = exports.JavaFeatures_Utf8Validation = exports.JavaFeatures_NestInFileClassFeature_NestInFileClassSchema = exports.JavaFeatures_NestInFileClassFeature_NestInFileClass = exports.JavaFeatures_NestInFileClassFeatureSchema = exports.JavaFeaturesSchema = exports.file_google_protobuf_java_features = void 0; +const file_js_1 = require("../../../../codegenv2/file.js"); +const descriptor_pb_js_1 = require("./descriptor_pb.js"); +const message_js_1 = require("../../../../codegenv2/message.js"); +const enum_js_1 = require("../../../../codegenv2/enum.js"); +const extension_js_1 = require("../../../../codegenv2/extension.js"); +/** + * Describes the file google/protobuf/java_features.proto. + */ +exports.file_google_protobuf_java_features = (0, file_js_1.fileDesc)("CiNnb29nbGUvcHJvdG9idWYvamF2YV9mZWF0dXJlcy5wcm90bxICcGIi/QcKDEphdmFGZWF0dXJlcxL+AQoSbGVnYWN5X2Nsb3NlZF9lbnVtGAEgASgIQuEBiAEBmAEEmAEBogEJEgR0cnVlGIQHogEKEgVmYWxzZRjnB7IBuwEI6AcQ6AcasgFUaGUgbGVnYWN5IGNsb3NlZCBlbnVtIGJlaGF2aW9yIGluIEphdmEgaXMgZGVwcmVjYXRlZCBhbmQgaXMgc2NoZWR1bGVkIHRvIGJlIHJlbW92ZWQgaW4gZWRpdGlvbiAyMDI1LiAgU2VlIGh0dHA6Ly9wcm90b2J1Zi5kZXYvcHJvZ3JhbW1pbmctZ3VpZGVzL2VudW0vI2phdmEgZm9yIG1vcmUgaW5mb3JtYXRpb24uEp8CCg91dGY4X3ZhbGlkYXRpb24YAiABKA4yHy5wYi5KYXZhRmVhdHVyZXMuVXRmOFZhbGlkYXRpb25C5AGIAQGYAQSYAQGiAQwSB0RFRkFVTFQYhAeyAcgBCOgHEOkHGr8BVGhlIEphdmEtc3BlY2lmaWMgdXRmOCB2YWxpZGF0aW9uIGZlYXR1cmUgaXMgZGVwcmVjYXRlZCBhbmQgaXMgc2NoZWR1bGVkIHRvIGJlIHJlbW92ZWQgaW4gZWRpdGlvbiAyMDI1LiAgVXRmOCB2YWxpZGF0aW9uIGJlaGF2aW9yIHNob3VsZCB1c2UgdGhlIGdsb2JhbCBjcm9zcy1sYW5ndWFnZSB1dGY4X3ZhbGlkYXRpb24gZmVhdHVyZS4SMAoKbGFyZ2VfZW51bRgDIAEoCEIciAEBmAEGmAEBogEKEgVmYWxzZRiEB7IBAwjpBxJRCh91c2Vfb2xkX291dGVyX2NsYXNzbmFtZV9kZWZhdWx0GAQgASgIQiiIAQGYAQGiAQkSBHRydWUYhAeiAQoSBWZhbHNlGOkHsgEGCOkHIOkHEn8KEm5lc3RfaW5fZmlsZV9jbGFzcxgFIAEoDjI3LnBiLkphdmFGZWF0dXJlcy5OZXN0SW5GaWxlQ2xhc3NGZWF0dXJlLk5lc3RJbkZpbGVDbGFzc0IqiAECmAEDmAEGmAEIogELEgZMRUdBQ1kYhAeiAQcSAk5PGOkHsgEDCOkHGnwKFk5lc3RJbkZpbGVDbGFzc0ZlYXR1cmUiWAoPTmVzdEluRmlsZUNsYXNzEh4KGk5FU1RfSU5fRklMRV9DTEFTU19VTktOT1dOEAASBgoCTk8QARIHCgNZRVMQAhIUCgZMRUdBQ1kQAxoIIgYI6Qcg6QdKCAgBEICAgIACIkYKDlV0ZjhWYWxpZGF0aW9uEhsKF1VURjhfVkFMSURBVElPTl9VTktOT1dOEAASCwoHREVGQVVMVBABEgoKBlZFUklGWRACOkIKBGphdmESGy5nb29nbGUucHJvdG9idWYuRmVhdHVyZVNldBjpByABKAsyEC5wYi5KYXZhRmVhdHVyZXNSBGphdmFCKAoTY29tLmdvb2dsZS5wcm90b2J1ZkIRSmF2YUZlYXR1cmVzUHJvdG8", [descriptor_pb_js_1.file_google_protobuf_descriptor]); +/** + * Describes the message pb.JavaFeatures. + * Use `create(JavaFeaturesSchema)` to create a new message. + */ +exports.JavaFeaturesSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_java_features, 0); +/** + * Describes the message pb.JavaFeatures.NestInFileClassFeature. + * Use `create(JavaFeatures_NestInFileClassFeatureSchema)` to create a new message. + */ +exports.JavaFeatures_NestInFileClassFeatureSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_java_features, 0, 0); +/** + * @generated from enum pb.JavaFeatures.NestInFileClassFeature.NestInFileClass + */ +var JavaFeatures_NestInFileClassFeature_NestInFileClass; +(function (JavaFeatures_NestInFileClassFeature_NestInFileClass) { + /** + * Invalid default, which should never be used. + * + * @generated from enum value: NEST_IN_FILE_CLASS_UNKNOWN = 0; + */ + JavaFeatures_NestInFileClassFeature_NestInFileClass[JavaFeatures_NestInFileClassFeature_NestInFileClass["NEST_IN_FILE_CLASS_UNKNOWN"] = 0] = "NEST_IN_FILE_CLASS_UNKNOWN"; + /** + * Do not nest the generated class in the file class. + * + * @generated from enum value: NO = 1; + */ + JavaFeatures_NestInFileClassFeature_NestInFileClass[JavaFeatures_NestInFileClassFeature_NestInFileClass["NO"] = 1] = "NO"; + /** + * Nest the generated class in the file class. + * + * @generated from enum value: YES = 2; + */ + JavaFeatures_NestInFileClassFeature_NestInFileClass[JavaFeatures_NestInFileClassFeature_NestInFileClass["YES"] = 2] = "YES"; + /** + * Fall back to the `java_multiple_files` option. Users won't be able to + * set this option. + * + * @generated from enum value: LEGACY = 3; + */ + JavaFeatures_NestInFileClassFeature_NestInFileClass[JavaFeatures_NestInFileClassFeature_NestInFileClass["LEGACY"] = 3] = "LEGACY"; +})(JavaFeatures_NestInFileClassFeature_NestInFileClass || (exports.JavaFeatures_NestInFileClassFeature_NestInFileClass = JavaFeatures_NestInFileClassFeature_NestInFileClass = {})); +/** + * Describes the enum pb.JavaFeatures.NestInFileClassFeature.NestInFileClass. + */ +exports.JavaFeatures_NestInFileClassFeature_NestInFileClassSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_java_features, 0, 0, 0); +/** + * The UTF8 validation strategy to use. + * + * @generated from enum pb.JavaFeatures.Utf8Validation + */ +var JavaFeatures_Utf8Validation; +(function (JavaFeatures_Utf8Validation) { + /** + * Invalid default, which should never be used. + * + * @generated from enum value: UTF8_VALIDATION_UNKNOWN = 0; + */ + JavaFeatures_Utf8Validation[JavaFeatures_Utf8Validation["UTF8_VALIDATION_UNKNOWN"] = 0] = "UTF8_VALIDATION_UNKNOWN"; + /** + * Respect the UTF8 validation behavior specified by the global + * utf8_validation feature. + * + * @generated from enum value: DEFAULT = 1; + */ + JavaFeatures_Utf8Validation[JavaFeatures_Utf8Validation["DEFAULT"] = 1] = "DEFAULT"; + /** + * Verifies UTF8 validity overriding the global utf8_validation + * feature. This represents the legacy java_string_check_utf8 option. + * + * @generated from enum value: VERIFY = 2; + */ + JavaFeatures_Utf8Validation[JavaFeatures_Utf8Validation["VERIFY"] = 2] = "VERIFY"; +})(JavaFeatures_Utf8Validation || (exports.JavaFeatures_Utf8Validation = JavaFeatures_Utf8Validation = {})); +/** + * Describes the enum pb.JavaFeatures.Utf8Validation. + */ +exports.JavaFeatures_Utf8ValidationSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_java_features, 0, 0); +/** + * @generated from extension: optional pb.JavaFeatures java = 1001; + */ +exports.java = (0, extension_js_1.extDesc)(exports.file_google_protobuf_java_features, 0); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/source_context_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/source_context_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d77cea4d3dabffe1f644c2aa9e16f4103be4e11a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/source_context_pb.d.ts @@ -0,0 +1,43 @@ +import type { GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/source_context.proto. + */ +export declare const file_google_protobuf_source_context: GenFile; +/** + * `SourceContext` represents information about the source of a + * protobuf element, like the file in which it is defined. + * + * @generated from message google.protobuf.SourceContext + */ +export type SourceContext = Message<"google.protobuf.SourceContext"> & { + /** + * The path-qualified name of the .proto file that contained the associated + * protobuf element. For example: `"google/protobuf/source_context.proto"`. + * + * @generated from field: string file_name = 1; + */ + fileName: string; +}; +/** + * `SourceContext` represents information about the source of a + * protobuf element, like the file in which it is defined. + * + * @generated from message google.protobuf.SourceContext + */ +export type SourceContextJson = { + /** + * The path-qualified name of the .proto file that contained the associated + * protobuf element. For example: `"google/protobuf/source_context.proto"`. + * + * @generated from field: string file_name = 1; + */ + fileName?: string; +}; +/** + * Describes the message google.protobuf.SourceContext. + * Use `create(SourceContextSchema)` to create a new message. + */ +export declare const SourceContextSchema: GenMessage; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/source_context_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/source_context_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..cee461edbcb8ca0efa2873928ae2d5ac17501346 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/source_context_pb.js @@ -0,0 +1,27 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SourceContextSchema = exports.file_google_protobuf_source_context = void 0; +const file_js_1 = require("../../../../codegenv2/file.js"); +const message_js_1 = require("../../../../codegenv2/message.js"); +/** + * Describes the file google/protobuf/source_context.proto. + */ +exports.file_google_protobuf_source_context = (0, file_js_1.fileDesc)("CiRnb29nbGUvcHJvdG9idWYvc291cmNlX2NvbnRleHQucHJvdG8SD2dvb2dsZS5wcm90b2J1ZiIiCg1Tb3VyY2VDb250ZXh0EhEKCWZpbGVfbmFtZRgBIAEoCUKKAQoTY29tLmdvb2dsZS5wcm90b2J1ZkISU291cmNlQ29udGV4dFByb3RvUAFaNmdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL3NvdXJjZWNvbnRleHRwYqICA0dQQqoCHkdvb2dsZS5Qcm90b2J1Zi5XZWxsS25vd25UeXBlc2IGcHJvdG8z"); +/** + * Describes the message google.protobuf.SourceContext. + * Use `create(SourceContextSchema)` to create a new message. + */ +exports.SourceContextSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_source_context, 0); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/struct_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/struct_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1bb79e78479a6418473a710ecc2810b5019e411d --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/struct_pb.d.ts @@ -0,0 +1,195 @@ +import type { GenEnum, GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { Message } from "../../../../types.js"; +import type { JsonObject, JsonValue } from "../../../../json-value.js"; +/** + * Describes the file google/protobuf/struct.proto. + */ +export declare const file_google_protobuf_struct: GenFile; +/** + * `Struct` represents a structured data value, consisting of fields + * which map to dynamically typed values. In some languages, `Struct` + * might be supported by a native representation. For example, in + * scripting languages like JS a struct is represented as an + * object. The details of that representation are described together + * with the proto support for the language. + * + * The JSON representation for `Struct` is JSON object. + * + * @generated from message google.protobuf.Struct + */ +export type Struct = Message<"google.protobuf.Struct"> & { + /** + * Unordered map of dynamically typed values. + * + * @generated from field: map fields = 1; + */ + fields: { + [key: string]: Value; + }; +}; +/** + * `Struct` represents a structured data value, consisting of fields + * which map to dynamically typed values. In some languages, `Struct` + * might be supported by a native representation. For example, in + * scripting languages like JS a struct is represented as an + * object. The details of that representation are described together + * with the proto support for the language. + * + * The JSON representation for `Struct` is JSON object. + * + * @generated from message google.protobuf.Struct + */ +export type StructJson = JsonObject; +/** + * Describes the message google.protobuf.Struct. + * Use `create(StructSchema)` to create a new message. + */ +export declare const StructSchema: GenMessage; +/** + * `Value` represents a dynamically typed value which can be either + * null, a number, a string, a boolean, a recursive struct value, or a + * list of values. A producer of value is expected to set one of these + * variants. Absence of any variant indicates an error. + * + * The JSON representation for `Value` is JSON value. + * + * @generated from message google.protobuf.Value + */ +export type Value = Message<"google.protobuf.Value"> & { + /** + * The kind of value. + * + * @generated from oneof google.protobuf.Value.kind + */ + kind: { + /** + * Represents a null value. + * + * @generated from field: google.protobuf.NullValue null_value = 1; + */ + value: NullValue; + case: "nullValue"; + } | { + /** + * Represents a double value. + * + * @generated from field: double number_value = 2; + */ + value: number; + case: "numberValue"; + } | { + /** + * Represents a string value. + * + * @generated from field: string string_value = 3; + */ + value: string; + case: "stringValue"; + } | { + /** + * Represents a boolean value. + * + * @generated from field: bool bool_value = 4; + */ + value: boolean; + case: "boolValue"; + } | { + /** + * Represents a structured value. + * + * @generated from field: google.protobuf.Struct struct_value = 5; + */ + value: Struct; + case: "structValue"; + } | { + /** + * Represents a repeated `Value`. + * + * @generated from field: google.protobuf.ListValue list_value = 6; + */ + value: ListValue; + case: "listValue"; + } | { + case: undefined; + value?: undefined; + }; +}; +/** + * `Value` represents a dynamically typed value which can be either + * null, a number, a string, a boolean, a recursive struct value, or a + * list of values. A producer of value is expected to set one of these + * variants. Absence of any variant indicates an error. + * + * The JSON representation for `Value` is JSON value. + * + * @generated from message google.protobuf.Value + */ +export type ValueJson = JsonValue; +/** + * Describes the message google.protobuf.Value. + * Use `create(ValueSchema)` to create a new message. + */ +export declare const ValueSchema: GenMessage; +/** + * `ListValue` is a wrapper around a repeated field of values. + * + * The JSON representation for `ListValue` is JSON array. + * + * @generated from message google.protobuf.ListValue + */ +export type ListValue = Message<"google.protobuf.ListValue"> & { + /** + * Repeated field of dynamically typed values. + * + * @generated from field: repeated google.protobuf.Value values = 1; + */ + values: Value[]; +}; +/** + * `ListValue` is a wrapper around a repeated field of values. + * + * The JSON representation for `ListValue` is JSON array. + * + * @generated from message google.protobuf.ListValue + */ +export type ListValueJson = JsonValue[]; +/** + * Describes the message google.protobuf.ListValue. + * Use `create(ListValueSchema)` to create a new message. + */ +export declare const ListValueSchema: GenMessage; +/** + * `NullValue` is a singleton enumeration to represent the null value for the + * `Value` type union. + * + * The JSON representation for `NullValue` is JSON `null`. + * + * @generated from enum google.protobuf.NullValue + */ +export declare enum NullValue { + /** + * Null value. + * + * @generated from enum value: NULL_VALUE = 0; + */ + NULL_VALUE = 0 +} +/** + * `NullValue` is a singleton enumeration to represent the null value for the + * `Value` type union. + * + * The JSON representation for `NullValue` is JSON `null`. + * + * @generated from enum google.protobuf.NullValue + */ +export type NullValueJson = null; +/** + * Describes the enum google.protobuf.NullValue. + */ +export declare const NullValueSchema: GenEnum; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/struct_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/struct_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..928494d8fa6e0552a289e46ab674de2191d2cd5f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/struct_pb.js @@ -0,0 +1,59 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.NullValueSchema = exports.NullValue = exports.ListValueSchema = exports.ValueSchema = exports.StructSchema = exports.file_google_protobuf_struct = void 0; +const file_js_1 = require("../../../../codegenv2/file.js"); +const message_js_1 = require("../../../../codegenv2/message.js"); +const enum_js_1 = require("../../../../codegenv2/enum.js"); +/** + * Describes the file google/protobuf/struct.proto. + */ +exports.file_google_protobuf_struct = (0, file_js_1.fileDesc)("Chxnb29nbGUvcHJvdG9idWYvc3RydWN0LnByb3RvEg9nb29nbGUucHJvdG9idWYihAEKBlN0cnVjdBIzCgZmaWVsZHMYASADKAsyIy5nb29nbGUucHJvdG9idWYuU3RydWN0LkZpZWxkc0VudHJ5GkUKC0ZpZWxkc0VudHJ5EgsKA2tleRgBIAEoCRIlCgV2YWx1ZRgCIAEoCzIWLmdvb2dsZS5wcm90b2J1Zi5WYWx1ZToCOAEi6gEKBVZhbHVlEjAKCm51bGxfdmFsdWUYASABKA4yGi5nb29nbGUucHJvdG9idWYuTnVsbFZhbHVlSAASFgoMbnVtYmVyX3ZhbHVlGAIgASgBSAASFgoMc3RyaW5nX3ZhbHVlGAMgASgJSAASFAoKYm9vbF92YWx1ZRgEIAEoCEgAEi8KDHN0cnVjdF92YWx1ZRgFIAEoCzIXLmdvb2dsZS5wcm90b2J1Zi5TdHJ1Y3RIABIwCgpsaXN0X3ZhbHVlGAYgASgLMhouZ29vZ2xlLnByb3RvYnVmLkxpc3RWYWx1ZUgAQgYKBGtpbmQiMwoJTGlzdFZhbHVlEiYKBnZhbHVlcxgBIAMoCzIWLmdvb2dsZS5wcm90b2J1Zi5WYWx1ZSobCglOdWxsVmFsdWUSDgoKTlVMTF9WQUxVRRAAQn8KE2NvbS5nb29nbGUucHJvdG9idWZCC1N0cnVjdFByb3RvUAFaL2dvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL3N0cnVjdHBi+AEBogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxLbm93blR5cGVzYgZwcm90bzM"); +/** + * Describes the message google.protobuf.Struct. + * Use `create(StructSchema)` to create a new message. + */ +exports.StructSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_struct, 0); +/** + * Describes the message google.protobuf.Value. + * Use `create(ValueSchema)` to create a new message. + */ +exports.ValueSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_struct, 1); +/** + * Describes the message google.protobuf.ListValue. + * Use `create(ListValueSchema)` to create a new message. + */ +exports.ListValueSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_struct, 2); +/** + * `NullValue` is a singleton enumeration to represent the null value for the + * `Value` type union. + * + * The JSON representation for `NullValue` is JSON `null`. + * + * @generated from enum google.protobuf.NullValue + */ +var NullValue; +(function (NullValue) { + /** + * Null value. + * + * @generated from enum value: NULL_VALUE = 0; + */ + NullValue[NullValue["NULL_VALUE"] = 0] = "NULL_VALUE"; +})(NullValue || (exports.NullValue = NullValue = {})); +/** + * Describes the enum google.protobuf.NullValue. + */ +exports.NullValueSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_struct, 0); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/timestamp_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/timestamp_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..84f52028e76e5e6b4c7c8e4c447681fe93678946 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/timestamp_pb.d.ts @@ -0,0 +1,221 @@ +import type { GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/timestamp.proto. + */ +export declare const file_google_protobuf_timestamp: GenFile; +/** + * A Timestamp represents a point in time independent of any time zone or local + * calendar, encoded as a count of seconds and fractions of seconds at + * nanosecond resolution. The count is relative to an epoch at UTC midnight on + * January 1, 1970, in the proleptic Gregorian calendar which extends the + * Gregorian calendar backwards to year one. + * + * All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap + * second table is needed for interpretation, using a [24-hour linear + * smear](https://developers.google.com/time/smear). + * + * The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By + * restricting to that range, we ensure that we can convert to and from [RFC + * 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. + * + * # Examples + * + * Example 1: Compute Timestamp from POSIX `time()`. + * + * Timestamp timestamp; + * timestamp.set_seconds(time(NULL)); + * timestamp.set_nanos(0); + * + * Example 2: Compute Timestamp from POSIX `gettimeofday()`. + * + * struct timeval tv; + * gettimeofday(&tv, NULL); + * + * Timestamp timestamp; + * timestamp.set_seconds(tv.tv_sec); + * timestamp.set_nanos(tv.tv_usec * 1000); + * + * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. + * + * FILETIME ft; + * GetSystemTimeAsFileTime(&ft); + * UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; + * + * // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z + * // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. + * Timestamp timestamp; + * timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); + * timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); + * + * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. + * + * long millis = System.currentTimeMillis(); + * + * Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) + * .setNanos((int) ((millis % 1000) * 1000000)).build(); + * + * Example 5: Compute Timestamp from Java `Instant.now()`. + * + * Instant now = Instant.now(); + * + * Timestamp timestamp = + * Timestamp.newBuilder().setSeconds(now.getEpochSecond()) + * .setNanos(now.getNano()).build(); + * + * Example 6: Compute Timestamp from current time in Python. + * + * timestamp = Timestamp() + * timestamp.GetCurrentTime() + * + * # JSON Mapping + * + * In JSON format, the Timestamp type is encoded as a string in the + * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the + * format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" + * where {year} is always expressed using four digits while {month}, {day}, + * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional + * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), + * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone + * is required. A proto3 JSON serializer should always use UTC (as indicated by + * "Z") when printing the Timestamp type and a proto3 JSON parser should be + * able to accept both UTC and other timezones (as indicated by an offset). + * + * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past + * 01:30 UTC on January 15, 2017. + * + * In JavaScript, one can convert a Date object to this format using the + * standard + * [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) + * method. In Python, a standard `datetime.datetime` object can be converted + * to this format using + * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with + * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use + * the Joda Time's [`ISODateTimeFormat.dateTime()`]( + * http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime() + * ) to obtain a formatter capable of generating timestamps in this format. + * + * + * @generated from message google.protobuf.Timestamp + */ +export type Timestamp = Message<"google.protobuf.Timestamp"> & { + /** + * Represents seconds of UTC time since Unix epoch + * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to + * 9999-12-31T23:59:59Z inclusive. + * + * @generated from field: int64 seconds = 1; + */ + seconds: bigint; + /** + * Non-negative fractions of a second at nanosecond resolution. Negative + * second values with fractions must still have non-negative nanos values + * that count forward in time. Must be from 0 to 999,999,999 + * inclusive. + * + * @generated from field: int32 nanos = 2; + */ + nanos: number; +}; +/** + * A Timestamp represents a point in time independent of any time zone or local + * calendar, encoded as a count of seconds and fractions of seconds at + * nanosecond resolution. The count is relative to an epoch at UTC midnight on + * January 1, 1970, in the proleptic Gregorian calendar which extends the + * Gregorian calendar backwards to year one. + * + * All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap + * second table is needed for interpretation, using a [24-hour linear + * smear](https://developers.google.com/time/smear). + * + * The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By + * restricting to that range, we ensure that we can convert to and from [RFC + * 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. + * + * # Examples + * + * Example 1: Compute Timestamp from POSIX `time()`. + * + * Timestamp timestamp; + * timestamp.set_seconds(time(NULL)); + * timestamp.set_nanos(0); + * + * Example 2: Compute Timestamp from POSIX `gettimeofday()`. + * + * struct timeval tv; + * gettimeofday(&tv, NULL); + * + * Timestamp timestamp; + * timestamp.set_seconds(tv.tv_sec); + * timestamp.set_nanos(tv.tv_usec * 1000); + * + * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. + * + * FILETIME ft; + * GetSystemTimeAsFileTime(&ft); + * UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; + * + * // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z + * // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. + * Timestamp timestamp; + * timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); + * timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); + * + * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. + * + * long millis = System.currentTimeMillis(); + * + * Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) + * .setNanos((int) ((millis % 1000) * 1000000)).build(); + * + * Example 5: Compute Timestamp from Java `Instant.now()`. + * + * Instant now = Instant.now(); + * + * Timestamp timestamp = + * Timestamp.newBuilder().setSeconds(now.getEpochSecond()) + * .setNanos(now.getNano()).build(); + * + * Example 6: Compute Timestamp from current time in Python. + * + * timestamp = Timestamp() + * timestamp.GetCurrentTime() + * + * # JSON Mapping + * + * In JSON format, the Timestamp type is encoded as a string in the + * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the + * format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" + * where {year} is always expressed using four digits while {month}, {day}, + * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional + * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), + * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone + * is required. A proto3 JSON serializer should always use UTC (as indicated by + * "Z") when printing the Timestamp type and a proto3 JSON parser should be + * able to accept both UTC and other timezones (as indicated by an offset). + * + * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past + * 01:30 UTC on January 15, 2017. + * + * In JavaScript, one can convert a Date object to this format using the + * standard + * [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) + * method. In Python, a standard `datetime.datetime` object can be converted + * to this format using + * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with + * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use + * the Joda Time's [`ISODateTimeFormat.dateTime()`]( + * http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime() + * ) to obtain a formatter capable of generating timestamps in this format. + * + * + * @generated from message google.protobuf.Timestamp + */ +export type TimestampJson = string; +/** + * Describes the message google.protobuf.Timestamp. + * Use `create(TimestampSchema)` to create a new message. + */ +export declare const TimestampSchema: GenMessage; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/timestamp_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/timestamp_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..cbca17804d54d152710bb9626e9ac3988dcde6f5 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/timestamp_pb.js @@ -0,0 +1,27 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.TimestampSchema = exports.file_google_protobuf_timestamp = void 0; +const file_js_1 = require("../../../../codegenv2/file.js"); +const message_js_1 = require("../../../../codegenv2/message.js"); +/** + * Describes the file google/protobuf/timestamp.proto. + */ +exports.file_google_protobuf_timestamp = (0, file_js_1.fileDesc)("Ch9nb29nbGUvcHJvdG9idWYvdGltZXN0YW1wLnByb3RvEg9nb29nbGUucHJvdG9idWYiKwoJVGltZXN0YW1wEg8KB3NlY29uZHMYASABKAMSDQoFbmFub3MYAiABKAVChQEKE2NvbS5nb29nbGUucHJvdG9idWZCDlRpbWVzdGFtcFByb3RvUAFaMmdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL3RpbWVzdGFtcHBi+AEBogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxLbm93blR5cGVzYgZwcm90bzM"); +/** + * Describes the message google.protobuf.Timestamp. + * Use `create(TimestampSchema)` to create a new message. + */ +exports.TimestampSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_timestamp, 0); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/type_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/type_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0c931ff6bf77066fb8377edfc48c3d275ad8a03e --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/type_pb.d.ts @@ -0,0 +1,674 @@ +import type { GenEnum, GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { Any, AnyJson } from "./any_pb.js"; +import type { SourceContext, SourceContextJson } from "./source_context_pb.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/type.proto. + */ +export declare const file_google_protobuf_type: GenFile; +/** + * A protocol buffer message type. + * + * @generated from message google.protobuf.Type + */ +export type Type = Message<"google.protobuf.Type"> & { + /** + * The fully qualified message name. + * + * @generated from field: string name = 1; + */ + name: string; + /** + * The list of fields. + * + * @generated from field: repeated google.protobuf.Field fields = 2; + */ + fields: Field[]; + /** + * The list of types appearing in `oneof` definitions in this type. + * + * @generated from field: repeated string oneofs = 3; + */ + oneofs: string[]; + /** + * The protocol buffer options. + * + * @generated from field: repeated google.protobuf.Option options = 4; + */ + options: Option[]; + /** + * The source context. + * + * @generated from field: google.protobuf.SourceContext source_context = 5; + */ + sourceContext?: SourceContext; + /** + * The source syntax. + * + * @generated from field: google.protobuf.Syntax syntax = 6; + */ + syntax: Syntax; + /** + * The source edition string, only valid when syntax is SYNTAX_EDITIONS. + * + * @generated from field: string edition = 7; + */ + edition: string; +}; +/** + * A protocol buffer message type. + * + * @generated from message google.protobuf.Type + */ +export type TypeJson = { + /** + * The fully qualified message name. + * + * @generated from field: string name = 1; + */ + name?: string; + /** + * The list of fields. + * + * @generated from field: repeated google.protobuf.Field fields = 2; + */ + fields?: FieldJson[]; + /** + * The list of types appearing in `oneof` definitions in this type. + * + * @generated from field: repeated string oneofs = 3; + */ + oneofs?: string[]; + /** + * The protocol buffer options. + * + * @generated from field: repeated google.protobuf.Option options = 4; + */ + options?: OptionJson[]; + /** + * The source context. + * + * @generated from field: google.protobuf.SourceContext source_context = 5; + */ + sourceContext?: SourceContextJson; + /** + * The source syntax. + * + * @generated from field: google.protobuf.Syntax syntax = 6; + */ + syntax?: SyntaxJson; + /** + * The source edition string, only valid when syntax is SYNTAX_EDITIONS. + * + * @generated from field: string edition = 7; + */ + edition?: string; +}; +/** + * Describes the message google.protobuf.Type. + * Use `create(TypeSchema)` to create a new message. + */ +export declare const TypeSchema: GenMessage; +/** + * A single field of a message type. + * + * @generated from message google.protobuf.Field + */ +export type Field = Message<"google.protobuf.Field"> & { + /** + * The field type. + * + * @generated from field: google.protobuf.Field.Kind kind = 1; + */ + kind: Field_Kind; + /** + * The field cardinality. + * + * @generated from field: google.protobuf.Field.Cardinality cardinality = 2; + */ + cardinality: Field_Cardinality; + /** + * The field number. + * + * @generated from field: int32 number = 3; + */ + number: number; + /** + * The field name. + * + * @generated from field: string name = 4; + */ + name: string; + /** + * The field type URL, without the scheme, for message or enumeration + * types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`. + * + * @generated from field: string type_url = 6; + */ + typeUrl: string; + /** + * The index of the field type in `Type.oneofs`, for message or enumeration + * types. The first type has index 1; zero means the type is not in the list. + * + * @generated from field: int32 oneof_index = 7; + */ + oneofIndex: number; + /** + * Whether to use alternative packed wire representation. + * + * @generated from field: bool packed = 8; + */ + packed: boolean; + /** + * The protocol buffer options. + * + * @generated from field: repeated google.protobuf.Option options = 9; + */ + options: Option[]; + /** + * The field JSON name. + * + * @generated from field: string json_name = 10; + */ + jsonName: string; + /** + * The string value of the default value of this field. Proto2 syntax only. + * + * @generated from field: string default_value = 11; + */ + defaultValue: string; +}; +/** + * A single field of a message type. + * + * @generated from message google.protobuf.Field + */ +export type FieldJson = { + /** + * The field type. + * + * @generated from field: google.protobuf.Field.Kind kind = 1; + */ + kind?: Field_KindJson; + /** + * The field cardinality. + * + * @generated from field: google.protobuf.Field.Cardinality cardinality = 2; + */ + cardinality?: Field_CardinalityJson; + /** + * The field number. + * + * @generated from field: int32 number = 3; + */ + number?: number; + /** + * The field name. + * + * @generated from field: string name = 4; + */ + name?: string; + /** + * The field type URL, without the scheme, for message or enumeration + * types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`. + * + * @generated from field: string type_url = 6; + */ + typeUrl?: string; + /** + * The index of the field type in `Type.oneofs`, for message or enumeration + * types. The first type has index 1; zero means the type is not in the list. + * + * @generated from field: int32 oneof_index = 7; + */ + oneofIndex?: number; + /** + * Whether to use alternative packed wire representation. + * + * @generated from field: bool packed = 8; + */ + packed?: boolean; + /** + * The protocol buffer options. + * + * @generated from field: repeated google.protobuf.Option options = 9; + */ + options?: OptionJson[]; + /** + * The field JSON name. + * + * @generated from field: string json_name = 10; + */ + jsonName?: string; + /** + * The string value of the default value of this field. Proto2 syntax only. + * + * @generated from field: string default_value = 11; + */ + defaultValue?: string; +}; +/** + * Describes the message google.protobuf.Field. + * Use `create(FieldSchema)` to create a new message. + */ +export declare const FieldSchema: GenMessage; +/** + * Basic field types. + * + * @generated from enum google.protobuf.Field.Kind + */ +export declare enum Field_Kind { + /** + * Field type unknown. + * + * @generated from enum value: TYPE_UNKNOWN = 0; + */ + TYPE_UNKNOWN = 0, + /** + * Field type double. + * + * @generated from enum value: TYPE_DOUBLE = 1; + */ + TYPE_DOUBLE = 1, + /** + * Field type float. + * + * @generated from enum value: TYPE_FLOAT = 2; + */ + TYPE_FLOAT = 2, + /** + * Field type int64. + * + * @generated from enum value: TYPE_INT64 = 3; + */ + TYPE_INT64 = 3, + /** + * Field type uint64. + * + * @generated from enum value: TYPE_UINT64 = 4; + */ + TYPE_UINT64 = 4, + /** + * Field type int32. + * + * @generated from enum value: TYPE_INT32 = 5; + */ + TYPE_INT32 = 5, + /** + * Field type fixed64. + * + * @generated from enum value: TYPE_FIXED64 = 6; + */ + TYPE_FIXED64 = 6, + /** + * Field type fixed32. + * + * @generated from enum value: TYPE_FIXED32 = 7; + */ + TYPE_FIXED32 = 7, + /** + * Field type bool. + * + * @generated from enum value: TYPE_BOOL = 8; + */ + TYPE_BOOL = 8, + /** + * Field type string. + * + * @generated from enum value: TYPE_STRING = 9; + */ + TYPE_STRING = 9, + /** + * Field type group. Proto2 syntax only, and deprecated. + * + * @generated from enum value: TYPE_GROUP = 10; + */ + TYPE_GROUP = 10, + /** + * Field type message. + * + * @generated from enum value: TYPE_MESSAGE = 11; + */ + TYPE_MESSAGE = 11, + /** + * Field type bytes. + * + * @generated from enum value: TYPE_BYTES = 12; + */ + TYPE_BYTES = 12, + /** + * Field type uint32. + * + * @generated from enum value: TYPE_UINT32 = 13; + */ + TYPE_UINT32 = 13, + /** + * Field type enum. + * + * @generated from enum value: TYPE_ENUM = 14; + */ + TYPE_ENUM = 14, + /** + * Field type sfixed32. + * + * @generated from enum value: TYPE_SFIXED32 = 15; + */ + TYPE_SFIXED32 = 15, + /** + * Field type sfixed64. + * + * @generated from enum value: TYPE_SFIXED64 = 16; + */ + TYPE_SFIXED64 = 16, + /** + * Field type sint32. + * + * @generated from enum value: TYPE_SINT32 = 17; + */ + TYPE_SINT32 = 17, + /** + * Field type sint64. + * + * @generated from enum value: TYPE_SINT64 = 18; + */ + TYPE_SINT64 = 18 +} +/** + * Basic field types. + * + * @generated from enum google.protobuf.Field.Kind + */ +export type Field_KindJson = "TYPE_UNKNOWN" | "TYPE_DOUBLE" | "TYPE_FLOAT" | "TYPE_INT64" | "TYPE_UINT64" | "TYPE_INT32" | "TYPE_FIXED64" | "TYPE_FIXED32" | "TYPE_BOOL" | "TYPE_STRING" | "TYPE_GROUP" | "TYPE_MESSAGE" | "TYPE_BYTES" | "TYPE_UINT32" | "TYPE_ENUM" | "TYPE_SFIXED32" | "TYPE_SFIXED64" | "TYPE_SINT32" | "TYPE_SINT64"; +/** + * Describes the enum google.protobuf.Field.Kind. + */ +export declare const Field_KindSchema: GenEnum; +/** + * Whether a field is optional, required, or repeated. + * + * @generated from enum google.protobuf.Field.Cardinality + */ +export declare enum Field_Cardinality { + /** + * For fields with unknown cardinality. + * + * @generated from enum value: CARDINALITY_UNKNOWN = 0; + */ + UNKNOWN = 0, + /** + * For optional fields. + * + * @generated from enum value: CARDINALITY_OPTIONAL = 1; + */ + OPTIONAL = 1, + /** + * For required fields. Proto2 syntax only. + * + * @generated from enum value: CARDINALITY_REQUIRED = 2; + */ + REQUIRED = 2, + /** + * For repeated fields. + * + * @generated from enum value: CARDINALITY_REPEATED = 3; + */ + REPEATED = 3 +} +/** + * Whether a field is optional, required, or repeated. + * + * @generated from enum google.protobuf.Field.Cardinality + */ +export type Field_CardinalityJson = "CARDINALITY_UNKNOWN" | "CARDINALITY_OPTIONAL" | "CARDINALITY_REQUIRED" | "CARDINALITY_REPEATED"; +/** + * Describes the enum google.protobuf.Field.Cardinality. + */ +export declare const Field_CardinalitySchema: GenEnum; +/** + * Enum type definition. + * + * @generated from message google.protobuf.Enum + */ +export type Enum = Message<"google.protobuf.Enum"> & { + /** + * Enum type name. + * + * @generated from field: string name = 1; + */ + name: string; + /** + * Enum value definitions. + * + * @generated from field: repeated google.protobuf.EnumValue enumvalue = 2; + */ + enumvalue: EnumValue[]; + /** + * Protocol buffer options. + * + * @generated from field: repeated google.protobuf.Option options = 3; + */ + options: Option[]; + /** + * The source context. + * + * @generated from field: google.protobuf.SourceContext source_context = 4; + */ + sourceContext?: SourceContext; + /** + * The source syntax. + * + * @generated from field: google.protobuf.Syntax syntax = 5; + */ + syntax: Syntax; + /** + * The source edition string, only valid when syntax is SYNTAX_EDITIONS. + * + * @generated from field: string edition = 6; + */ + edition: string; +}; +/** + * Enum type definition. + * + * @generated from message google.protobuf.Enum + */ +export type EnumJson = { + /** + * Enum type name. + * + * @generated from field: string name = 1; + */ + name?: string; + /** + * Enum value definitions. + * + * @generated from field: repeated google.protobuf.EnumValue enumvalue = 2; + */ + enumvalue?: EnumValueJson[]; + /** + * Protocol buffer options. + * + * @generated from field: repeated google.protobuf.Option options = 3; + */ + options?: OptionJson[]; + /** + * The source context. + * + * @generated from field: google.protobuf.SourceContext source_context = 4; + */ + sourceContext?: SourceContextJson; + /** + * The source syntax. + * + * @generated from field: google.protobuf.Syntax syntax = 5; + */ + syntax?: SyntaxJson; + /** + * The source edition string, only valid when syntax is SYNTAX_EDITIONS. + * + * @generated from field: string edition = 6; + */ + edition?: string; +}; +/** + * Describes the message google.protobuf.Enum. + * Use `create(EnumSchema)` to create a new message. + */ +export declare const EnumSchema: GenMessage; +/** + * Enum value definition. + * + * @generated from message google.protobuf.EnumValue + */ +export type EnumValue = Message<"google.protobuf.EnumValue"> & { + /** + * Enum value name. + * + * @generated from field: string name = 1; + */ + name: string; + /** + * Enum value number. + * + * @generated from field: int32 number = 2; + */ + number: number; + /** + * Protocol buffer options. + * + * @generated from field: repeated google.protobuf.Option options = 3; + */ + options: Option[]; +}; +/** + * Enum value definition. + * + * @generated from message google.protobuf.EnumValue + */ +export type EnumValueJson = { + /** + * Enum value name. + * + * @generated from field: string name = 1; + */ + name?: string; + /** + * Enum value number. + * + * @generated from field: int32 number = 2; + */ + number?: number; + /** + * Protocol buffer options. + * + * @generated from field: repeated google.protobuf.Option options = 3; + */ + options?: OptionJson[]; +}; +/** + * Describes the message google.protobuf.EnumValue. + * Use `create(EnumValueSchema)` to create a new message. + */ +export declare const EnumValueSchema: GenMessage; +/** + * A protocol buffer option, which can be attached to a message, field, + * enumeration, etc. + * + * @generated from message google.protobuf.Option + */ +export type Option = Message<"google.protobuf.Option"> & { + /** + * The option's name. For protobuf built-in options (options defined in + * descriptor.proto), this is the short name. For example, `"map_entry"`. + * For custom options, it should be the fully-qualified name. For example, + * `"google.api.http"`. + * + * @generated from field: string name = 1; + */ + name: string; + /** + * The option's value packed in an Any message. If the value is a primitive, + * the corresponding wrapper type defined in google/protobuf/wrappers.proto + * should be used. If the value is an enum, it should be stored as an int32 + * value using the google.protobuf.Int32Value type. + * + * @generated from field: google.protobuf.Any value = 2; + */ + value?: Any; +}; +/** + * A protocol buffer option, which can be attached to a message, field, + * enumeration, etc. + * + * @generated from message google.protobuf.Option + */ +export type OptionJson = { + /** + * The option's name. For protobuf built-in options (options defined in + * descriptor.proto), this is the short name. For example, `"map_entry"`. + * For custom options, it should be the fully-qualified name. For example, + * `"google.api.http"`. + * + * @generated from field: string name = 1; + */ + name?: string; + /** + * The option's value packed in an Any message. If the value is a primitive, + * the corresponding wrapper type defined in google/protobuf/wrappers.proto + * should be used. If the value is an enum, it should be stored as an int32 + * value using the google.protobuf.Int32Value type. + * + * @generated from field: google.protobuf.Any value = 2; + */ + value?: AnyJson; +}; +/** + * Describes the message google.protobuf.Option. + * Use `create(OptionSchema)` to create a new message. + */ +export declare const OptionSchema: GenMessage; +/** + * The syntax in which a protocol buffer element is defined. + * + * @generated from enum google.protobuf.Syntax + */ +export declare enum Syntax { + /** + * Syntax `proto2`. + * + * @generated from enum value: SYNTAX_PROTO2 = 0; + */ + PROTO2 = 0, + /** + * Syntax `proto3`. + * + * @generated from enum value: SYNTAX_PROTO3 = 1; + */ + PROTO3 = 1, + /** + * Syntax `editions`. + * + * @generated from enum value: SYNTAX_EDITIONS = 2; + */ + EDITIONS = 2 +} +/** + * The syntax in which a protocol buffer element is defined. + * + * @generated from enum google.protobuf.Syntax + */ +export type SyntaxJson = "SYNTAX_PROTO2" | "SYNTAX_PROTO3" | "SYNTAX_EDITIONS"; +/** + * Describes the enum google.protobuf.Syntax. + */ +export declare const SyntaxSchema: GenEnum; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/type_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/type_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..12110edd44758dda27c3cb0d106579cc9f29a610 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/type_pb.js @@ -0,0 +1,242 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SyntaxSchema = exports.Syntax = exports.OptionSchema = exports.EnumValueSchema = exports.EnumSchema = exports.Field_CardinalitySchema = exports.Field_Cardinality = exports.Field_KindSchema = exports.Field_Kind = exports.FieldSchema = exports.TypeSchema = exports.file_google_protobuf_type = void 0; +const file_js_1 = require("../../../../codegenv2/file.js"); +const any_pb_js_1 = require("./any_pb.js"); +const source_context_pb_js_1 = require("./source_context_pb.js"); +const message_js_1 = require("../../../../codegenv2/message.js"); +const enum_js_1 = require("../../../../codegenv2/enum.js"); +/** + * Describes the file google/protobuf/type.proto. + */ +exports.file_google_protobuf_type = (0, file_js_1.fileDesc)("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", [any_pb_js_1.file_google_protobuf_any, source_context_pb_js_1.file_google_protobuf_source_context]); +/** + * Describes the message google.protobuf.Type. + * Use `create(TypeSchema)` to create a new message. + */ +exports.TypeSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_type, 0); +/** + * Describes the message google.protobuf.Field. + * Use `create(FieldSchema)` to create a new message. + */ +exports.FieldSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_type, 1); +/** + * Basic field types. + * + * @generated from enum google.protobuf.Field.Kind + */ +var Field_Kind; +(function (Field_Kind) { + /** + * Field type unknown. + * + * @generated from enum value: TYPE_UNKNOWN = 0; + */ + Field_Kind[Field_Kind["TYPE_UNKNOWN"] = 0] = "TYPE_UNKNOWN"; + /** + * Field type double. + * + * @generated from enum value: TYPE_DOUBLE = 1; + */ + Field_Kind[Field_Kind["TYPE_DOUBLE"] = 1] = "TYPE_DOUBLE"; + /** + * Field type float. + * + * @generated from enum value: TYPE_FLOAT = 2; + */ + Field_Kind[Field_Kind["TYPE_FLOAT"] = 2] = "TYPE_FLOAT"; + /** + * Field type int64. + * + * @generated from enum value: TYPE_INT64 = 3; + */ + Field_Kind[Field_Kind["TYPE_INT64"] = 3] = "TYPE_INT64"; + /** + * Field type uint64. + * + * @generated from enum value: TYPE_UINT64 = 4; + */ + Field_Kind[Field_Kind["TYPE_UINT64"] = 4] = "TYPE_UINT64"; + /** + * Field type int32. + * + * @generated from enum value: TYPE_INT32 = 5; + */ + Field_Kind[Field_Kind["TYPE_INT32"] = 5] = "TYPE_INT32"; + /** + * Field type fixed64. + * + * @generated from enum value: TYPE_FIXED64 = 6; + */ + Field_Kind[Field_Kind["TYPE_FIXED64"] = 6] = "TYPE_FIXED64"; + /** + * Field type fixed32. + * + * @generated from enum value: TYPE_FIXED32 = 7; + */ + Field_Kind[Field_Kind["TYPE_FIXED32"] = 7] = "TYPE_FIXED32"; + /** + * Field type bool. + * + * @generated from enum value: TYPE_BOOL = 8; + */ + Field_Kind[Field_Kind["TYPE_BOOL"] = 8] = "TYPE_BOOL"; + /** + * Field type string. + * + * @generated from enum value: TYPE_STRING = 9; + */ + Field_Kind[Field_Kind["TYPE_STRING"] = 9] = "TYPE_STRING"; + /** + * Field type group. Proto2 syntax only, and deprecated. + * + * @generated from enum value: TYPE_GROUP = 10; + */ + Field_Kind[Field_Kind["TYPE_GROUP"] = 10] = "TYPE_GROUP"; + /** + * Field type message. + * + * @generated from enum value: TYPE_MESSAGE = 11; + */ + Field_Kind[Field_Kind["TYPE_MESSAGE"] = 11] = "TYPE_MESSAGE"; + /** + * Field type bytes. + * + * @generated from enum value: TYPE_BYTES = 12; + */ + Field_Kind[Field_Kind["TYPE_BYTES"] = 12] = "TYPE_BYTES"; + /** + * Field type uint32. + * + * @generated from enum value: TYPE_UINT32 = 13; + */ + Field_Kind[Field_Kind["TYPE_UINT32"] = 13] = "TYPE_UINT32"; + /** + * Field type enum. + * + * @generated from enum value: TYPE_ENUM = 14; + */ + Field_Kind[Field_Kind["TYPE_ENUM"] = 14] = "TYPE_ENUM"; + /** + * Field type sfixed32. + * + * @generated from enum value: TYPE_SFIXED32 = 15; + */ + Field_Kind[Field_Kind["TYPE_SFIXED32"] = 15] = "TYPE_SFIXED32"; + /** + * Field type sfixed64. + * + * @generated from enum value: TYPE_SFIXED64 = 16; + */ + Field_Kind[Field_Kind["TYPE_SFIXED64"] = 16] = "TYPE_SFIXED64"; + /** + * Field type sint32. + * + * @generated from enum value: TYPE_SINT32 = 17; + */ + Field_Kind[Field_Kind["TYPE_SINT32"] = 17] = "TYPE_SINT32"; + /** + * Field type sint64. + * + * @generated from enum value: TYPE_SINT64 = 18; + */ + Field_Kind[Field_Kind["TYPE_SINT64"] = 18] = "TYPE_SINT64"; +})(Field_Kind || (exports.Field_Kind = Field_Kind = {})); +/** + * Describes the enum google.protobuf.Field.Kind. + */ +exports.Field_KindSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_type, 1, 0); +/** + * Whether a field is optional, required, or repeated. + * + * @generated from enum google.protobuf.Field.Cardinality + */ +var Field_Cardinality; +(function (Field_Cardinality) { + /** + * For fields with unknown cardinality. + * + * @generated from enum value: CARDINALITY_UNKNOWN = 0; + */ + Field_Cardinality[Field_Cardinality["UNKNOWN"] = 0] = "UNKNOWN"; + /** + * For optional fields. + * + * @generated from enum value: CARDINALITY_OPTIONAL = 1; + */ + Field_Cardinality[Field_Cardinality["OPTIONAL"] = 1] = "OPTIONAL"; + /** + * For required fields. Proto2 syntax only. + * + * @generated from enum value: CARDINALITY_REQUIRED = 2; + */ + Field_Cardinality[Field_Cardinality["REQUIRED"] = 2] = "REQUIRED"; + /** + * For repeated fields. + * + * @generated from enum value: CARDINALITY_REPEATED = 3; + */ + Field_Cardinality[Field_Cardinality["REPEATED"] = 3] = "REPEATED"; +})(Field_Cardinality || (exports.Field_Cardinality = Field_Cardinality = {})); +/** + * Describes the enum google.protobuf.Field.Cardinality. + */ +exports.Field_CardinalitySchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_type, 1, 1); +/** + * Describes the message google.protobuf.Enum. + * Use `create(EnumSchema)` to create a new message. + */ +exports.EnumSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_type, 2); +/** + * Describes the message google.protobuf.EnumValue. + * Use `create(EnumValueSchema)` to create a new message. + */ +exports.EnumValueSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_type, 3); +/** + * Describes the message google.protobuf.Option. + * Use `create(OptionSchema)` to create a new message. + */ +exports.OptionSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_type, 4); +/** + * The syntax in which a protocol buffer element is defined. + * + * @generated from enum google.protobuf.Syntax + */ +var Syntax; +(function (Syntax) { + /** + * Syntax `proto2`. + * + * @generated from enum value: SYNTAX_PROTO2 = 0; + */ + Syntax[Syntax["PROTO2"] = 0] = "PROTO2"; + /** + * Syntax `proto3`. + * + * @generated from enum value: SYNTAX_PROTO3 = 1; + */ + Syntax[Syntax["PROTO3"] = 1] = "PROTO3"; + /** + * Syntax `editions`. + * + * @generated from enum value: SYNTAX_EDITIONS = 2; + */ + Syntax[Syntax["EDITIONS"] = 2] = "EDITIONS"; +})(Syntax || (exports.Syntax = Syntax = {})); +/** + * Describes the enum google.protobuf.Syntax. + */ +exports.SyntaxSchema = (0, enum_js_1.enumDesc)(exports.file_google_protobuf_type, 0); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/wrappers_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/wrappers_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c63820ac4f467dc67e9328a8e769ec81d129ed8a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/wrappers_pb.d.ts @@ -0,0 +1,330 @@ +import type { GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/wrappers.proto. + */ +export declare const file_google_protobuf_wrappers: GenFile; +/** + * Wrapper message for `double`. + * + * The JSON representation for `DoubleValue` is JSON number. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.DoubleValue + */ +export type DoubleValue = Message<"google.protobuf.DoubleValue"> & { + /** + * The double value. + * + * @generated from field: double value = 1; + */ + value: number; +}; +/** + * Wrapper message for `double`. + * + * The JSON representation for `DoubleValue` is JSON number. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.DoubleValue + */ +export type DoubleValueJson = number | "NaN" | "Infinity" | "-Infinity"; +/** + * Describes the message google.protobuf.DoubleValue. + * Use `create(DoubleValueSchema)` to create a new message. + */ +export declare const DoubleValueSchema: GenMessage; +/** + * Wrapper message for `float`. + * + * The JSON representation for `FloatValue` is JSON number. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.FloatValue + */ +export type FloatValue = Message<"google.protobuf.FloatValue"> & { + /** + * The float value. + * + * @generated from field: float value = 1; + */ + value: number; +}; +/** + * Wrapper message for `float`. + * + * The JSON representation for `FloatValue` is JSON number. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.FloatValue + */ +export type FloatValueJson = number | "NaN" | "Infinity" | "-Infinity"; +/** + * Describes the message google.protobuf.FloatValue. + * Use `create(FloatValueSchema)` to create a new message. + */ +export declare const FloatValueSchema: GenMessage; +/** + * Wrapper message for `int64`. + * + * The JSON representation for `Int64Value` is JSON string. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.Int64Value + */ +export type Int64Value = Message<"google.protobuf.Int64Value"> & { + /** + * The int64 value. + * + * @generated from field: int64 value = 1; + */ + value: bigint; +}; +/** + * Wrapper message for `int64`. + * + * The JSON representation for `Int64Value` is JSON string. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.Int64Value + */ +export type Int64ValueJson = string; +/** + * Describes the message google.protobuf.Int64Value. + * Use `create(Int64ValueSchema)` to create a new message. + */ +export declare const Int64ValueSchema: GenMessage; +/** + * Wrapper message for `uint64`. + * + * The JSON representation for `UInt64Value` is JSON string. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.UInt64Value + */ +export type UInt64Value = Message<"google.protobuf.UInt64Value"> & { + /** + * The uint64 value. + * + * @generated from field: uint64 value = 1; + */ + value: bigint; +}; +/** + * Wrapper message for `uint64`. + * + * The JSON representation for `UInt64Value` is JSON string. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.UInt64Value + */ +export type UInt64ValueJson = string; +/** + * Describes the message google.protobuf.UInt64Value. + * Use `create(UInt64ValueSchema)` to create a new message. + */ +export declare const UInt64ValueSchema: GenMessage; +/** + * Wrapper message for `int32`. + * + * The JSON representation for `Int32Value` is JSON number. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.Int32Value + */ +export type Int32Value = Message<"google.protobuf.Int32Value"> & { + /** + * The int32 value. + * + * @generated from field: int32 value = 1; + */ + value: number; +}; +/** + * Wrapper message for `int32`. + * + * The JSON representation for `Int32Value` is JSON number. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.Int32Value + */ +export type Int32ValueJson = number; +/** + * Describes the message google.protobuf.Int32Value. + * Use `create(Int32ValueSchema)` to create a new message. + */ +export declare const Int32ValueSchema: GenMessage; +/** + * Wrapper message for `uint32`. + * + * The JSON representation for `UInt32Value` is JSON number. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.UInt32Value + */ +export type UInt32Value = Message<"google.protobuf.UInt32Value"> & { + /** + * The uint32 value. + * + * @generated from field: uint32 value = 1; + */ + value: number; +}; +/** + * Wrapper message for `uint32`. + * + * The JSON representation for `UInt32Value` is JSON number. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.UInt32Value + */ +export type UInt32ValueJson = number; +/** + * Describes the message google.protobuf.UInt32Value. + * Use `create(UInt32ValueSchema)` to create a new message. + */ +export declare const UInt32ValueSchema: GenMessage; +/** + * Wrapper message for `bool`. + * + * The JSON representation for `BoolValue` is JSON `true` and `false`. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.BoolValue + */ +export type BoolValue = Message<"google.protobuf.BoolValue"> & { + /** + * The bool value. + * + * @generated from field: bool value = 1; + */ + value: boolean; +}; +/** + * Wrapper message for `bool`. + * + * The JSON representation for `BoolValue` is JSON `true` and `false`. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.BoolValue + */ +export type BoolValueJson = boolean; +/** + * Describes the message google.protobuf.BoolValue. + * Use `create(BoolValueSchema)` to create a new message. + */ +export declare const BoolValueSchema: GenMessage; +/** + * Wrapper message for `string`. + * + * The JSON representation for `StringValue` is JSON string. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.StringValue + */ +export type StringValue = Message<"google.protobuf.StringValue"> & { + /** + * The string value. + * + * @generated from field: string value = 1; + */ + value: string; +}; +/** + * Wrapper message for `string`. + * + * The JSON representation for `StringValue` is JSON string. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.StringValue + */ +export type StringValueJson = string; +/** + * Describes the message google.protobuf.StringValue. + * Use `create(StringValueSchema)` to create a new message. + */ +export declare const StringValueSchema: GenMessage; +/** + * Wrapper message for `bytes`. + * + * The JSON representation for `BytesValue` is JSON string. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.BytesValue + */ +export type BytesValue = Message<"google.protobuf.BytesValue"> & { + /** + * The bytes value. + * + * @generated from field: bytes value = 1; + */ + value: Uint8Array; +}; +/** + * Wrapper message for `bytes`. + * + * The JSON representation for `BytesValue` is JSON string. + * + * Not recommended for use in new APIs, but still useful for legacy APIs and + * has no plan to be removed. + * + * @generated from message google.protobuf.BytesValue + */ +export type BytesValueJson = string; +/** + * Describes the message google.protobuf.BytesValue. + * Use `create(BytesValueSchema)` to create a new message. + */ +export declare const BytesValueSchema: GenMessage; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/wrappers_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/wrappers_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..ca7211edafdc989ce97b119d23272a13847e467e --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/gen/google/protobuf/wrappers_pb.js @@ -0,0 +1,67 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.BytesValueSchema = exports.StringValueSchema = exports.BoolValueSchema = exports.UInt32ValueSchema = exports.Int32ValueSchema = exports.UInt64ValueSchema = exports.Int64ValueSchema = exports.FloatValueSchema = exports.DoubleValueSchema = exports.file_google_protobuf_wrappers = void 0; +const file_js_1 = require("../../../../codegenv2/file.js"); +const message_js_1 = require("../../../../codegenv2/message.js"); +/** + * Describes the file google/protobuf/wrappers.proto. + */ +exports.file_google_protobuf_wrappers = (0, file_js_1.fileDesc)("Ch5nb29nbGUvcHJvdG9idWYvd3JhcHBlcnMucHJvdG8SD2dvb2dsZS5wcm90b2J1ZiIcCgtEb3VibGVWYWx1ZRINCgV2YWx1ZRgBIAEoASIbCgpGbG9hdFZhbHVlEg0KBXZhbHVlGAEgASgCIhsKCkludDY0VmFsdWUSDQoFdmFsdWUYASABKAMiHAoLVUludDY0VmFsdWUSDQoFdmFsdWUYASABKAQiGwoKSW50MzJWYWx1ZRINCgV2YWx1ZRgBIAEoBSIcCgtVSW50MzJWYWx1ZRINCgV2YWx1ZRgBIAEoDSIaCglCb29sVmFsdWUSDQoFdmFsdWUYASABKAgiHAoLU3RyaW5nVmFsdWUSDQoFdmFsdWUYASABKAkiGwoKQnl0ZXNWYWx1ZRINCgV2YWx1ZRgBIAEoDEKDAQoTY29tLmdvb2dsZS5wcm90b2J1ZkINV3JhcHBlcnNQcm90b1ABWjFnb29nbGUuZ29sYW5nLm9yZy9wcm90b2J1Zi90eXBlcy9rbm93bi93cmFwcGVyc3Bi+AEBogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxLbm93blR5cGVzYgZwcm90bzM"); +/** + * Describes the message google.protobuf.DoubleValue. + * Use `create(DoubleValueSchema)` to create a new message. + */ +exports.DoubleValueSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_wrappers, 0); +/** + * Describes the message google.protobuf.FloatValue. + * Use `create(FloatValueSchema)` to create a new message. + */ +exports.FloatValueSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_wrappers, 1); +/** + * Describes the message google.protobuf.Int64Value. + * Use `create(Int64ValueSchema)` to create a new message. + */ +exports.Int64ValueSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_wrappers, 2); +/** + * Describes the message google.protobuf.UInt64Value. + * Use `create(UInt64ValueSchema)` to create a new message. + */ +exports.UInt64ValueSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_wrappers, 3); +/** + * Describes the message google.protobuf.Int32Value. + * Use `create(Int32ValueSchema)` to create a new message. + */ +exports.Int32ValueSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_wrappers, 4); +/** + * Describes the message google.protobuf.UInt32Value. + * Use `create(UInt32ValueSchema)` to create a new message. + */ +exports.UInt32ValueSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_wrappers, 5); +/** + * Describes the message google.protobuf.BoolValue. + * Use `create(BoolValueSchema)` to create a new message. + */ +exports.BoolValueSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_wrappers, 6); +/** + * Describes the message google.protobuf.StringValue. + * Use `create(StringValueSchema)` to create a new message. + */ +exports.StringValueSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_wrappers, 7); +/** + * Describes the message google.protobuf.BytesValue. + * Use `create(BytesValueSchema)` to create a new message. + */ +exports.BytesValueSchema = (0, message_js_1.messageDesc)(exports.file_google_protobuf_wrappers, 8); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/index.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..23beb45157a3b3794413cd1d1d277f26e9828180 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/index.d.ts @@ -0,0 +1,18 @@ +export * from "./timestamp.js"; +export * from "./any.js"; +export * from "./wrappers.js"; +export * from "./gen/google/protobuf/any_pb.js"; +export * from "./gen/google/protobuf/api_pb.js"; +export * from "./gen/google/protobuf/cpp_features_pb.js"; +export * from "./gen/google/protobuf/descriptor_pb.js"; +export * from "./gen/google/protobuf/duration_pb.js"; +export * from "./gen/google/protobuf/empty_pb.js"; +export * from "./gen/google/protobuf/field_mask_pb.js"; +export * from "./gen/google/protobuf/go_features_pb.js"; +export * from "./gen/google/protobuf/java_features_pb.js"; +export * from "./gen/google/protobuf/source_context_pb.js"; +export * from "./gen/google/protobuf/struct_pb.js"; +export * from "./gen/google/protobuf/timestamp_pb.js"; +export * from "./gen/google/protobuf/type_pb.js"; +export * from "./gen/google/protobuf/wrappers_pb.js"; +export * from "./gen/google/protobuf/compiler/plugin_pb.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/index.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/index.js new file mode 100644 index 0000000000000000000000000000000000000000..3dd32b317271ad57288d333d75d343b6f19048c3 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/index.js @@ -0,0 +1,47 @@ +"use strict"; +// Copyright 2021-2025 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. +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./timestamp.js"), exports); +__exportStar(require("./any.js"), exports); +__exportStar(require("./wrappers.js"), exports); +__exportStar(require("./gen/google/protobuf/any_pb.js"), exports); +__exportStar(require("./gen/google/protobuf/api_pb.js"), exports); +__exportStar(require("./gen/google/protobuf/cpp_features_pb.js"), exports); +__exportStar(require("./gen/google/protobuf/descriptor_pb.js"), exports); +__exportStar(require("./gen/google/protobuf/duration_pb.js"), exports); +__exportStar(require("./gen/google/protobuf/empty_pb.js"), exports); +__exportStar(require("./gen/google/protobuf/field_mask_pb.js"), exports); +__exportStar(require("./gen/google/protobuf/go_features_pb.js"), exports); +__exportStar(require("./gen/google/protobuf/java_features_pb.js"), exports); +__exportStar(require("./gen/google/protobuf/source_context_pb.js"), exports); +__exportStar(require("./gen/google/protobuf/struct_pb.js"), exports); +__exportStar(require("./gen/google/protobuf/timestamp_pb.js"), exports); +__exportStar(require("./gen/google/protobuf/type_pb.js"), exports); +__exportStar(require("./gen/google/protobuf/wrappers_pb.js"), exports); +__exportStar(require("./gen/google/protobuf/compiler/plugin_pb.js"), exports); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/timestamp.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/timestamp.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6ae7c198b9d56f13da0d642a8a59c5704c30779b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/timestamp.d.ts @@ -0,0 +1,21 @@ +import type { Timestamp } from "./gen/google/protobuf/timestamp_pb.js"; +/** + * Create a google.protobuf.Timestamp for the current time. + */ +export declare function timestampNow(): Timestamp; +/** + * Create a google.protobuf.Timestamp message from an ECMAScript Date. + */ +export declare function timestampFromDate(date: Date): Timestamp; +/** + * Convert a google.protobuf.Timestamp message to an ECMAScript Date. + */ +export declare function timestampDate(timestamp: Timestamp): Date; +/** + * Create a google.protobuf.Timestamp message from a Unix timestamp in milliseconds. + */ +export declare function timestampFromMs(timestampMs: number): Timestamp; +/** + * Convert a google.protobuf.Timestamp to a Unix timestamp in milliseconds. + */ +export declare function timestampMs(timestamp: Timestamp): number; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/timestamp.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/timestamp.js new file mode 100644 index 0000000000000000000000000000000000000000..d0670b7a081570d06b753a4f0b659bf3bbcda338 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/timestamp.js @@ -0,0 +1,57 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.timestampNow = timestampNow; +exports.timestampFromDate = timestampFromDate; +exports.timestampDate = timestampDate; +exports.timestampFromMs = timestampFromMs; +exports.timestampMs = timestampMs; +const timestamp_pb_js_1 = require("./gen/google/protobuf/timestamp_pb.js"); +const create_js_1 = require("../create.js"); +const proto_int64_js_1 = require("../proto-int64.js"); +/** + * Create a google.protobuf.Timestamp for the current time. + */ +function timestampNow() { + return timestampFromDate(new Date()); +} +/** + * Create a google.protobuf.Timestamp message from an ECMAScript Date. + */ +function timestampFromDate(date) { + return timestampFromMs(date.getTime()); +} +/** + * Convert a google.protobuf.Timestamp message to an ECMAScript Date. + */ +function timestampDate(timestamp) { + return new Date(timestampMs(timestamp)); +} +/** + * Create a google.protobuf.Timestamp message from a Unix timestamp in milliseconds. + */ +function timestampFromMs(timestampMs) { + const seconds = Math.floor(timestampMs / 1000); + return (0, create_js_1.create)(timestamp_pb_js_1.TimestampSchema, { + seconds: proto_int64_js_1.protoInt64.parse(seconds), + nanos: (timestampMs - seconds * 1000) * 1000000, + }); +} +/** + * Convert a google.protobuf.Timestamp to a Unix timestamp in milliseconds. + */ +function timestampMs(timestamp) { + return (Number(timestamp.seconds) * 1000 + Math.round(timestamp.nanos / 1000000)); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/wrappers.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/wrappers.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f836b8e31979fa00595f95c3afc66e2e22120b2b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/wrappers.d.ts @@ -0,0 +1,15 @@ +import type { Message } from "../types.js"; +import type { BoolValue, BytesValue, DoubleValue, FloatValue, Int32Value, Int64Value, StringValue, UInt32Value, UInt64Value } from "./gen/google/protobuf/wrappers_pb.js"; +import type { DescField, DescMessage } from "../descriptors.js"; +export declare function isWrapper(arg: Message): arg is DoubleValue | FloatValue | Int64Value | UInt64Value | Int32Value | UInt32Value | BoolValue | StringValue | BytesValue; +export type WktWrapperDesc = DescMessage & { + fields: [ + DescField & { + fieldKind: "scalar"; + number: 1; + name: "value"; + oneof: undefined; + } + ]; +}; +export declare function isWrapperDesc(messageDesc: DescMessage): messageDesc is WktWrapperDesc; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/wrappers.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/wrappers.js new file mode 100644 index 0000000000000000000000000000000000000000..4456b58d68e7429106f3c11beaf7ce5a662b6581 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/cjs/wkt/wrappers.js @@ -0,0 +1,42 @@ +"use strict"; +// Copyright 2021-2025 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. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isWrapper = isWrapper; +exports.isWrapperDesc = isWrapperDesc; +function isWrapper(arg) { + return isWrapperTypeName(arg.$typeName); +} +function isWrapperDesc(messageDesc) { + const f = messageDesc.fields[0]; + return (isWrapperTypeName(messageDesc.typeName) && + f !== undefined && + f.fieldKind == "scalar" && + f.name == "value" && + f.number == 1); +} +function isWrapperTypeName(name) { + return (name.startsWith("google.protobuf.") && + [ + "DoubleValue", + "FloatValue", + "Int64Value", + "UInt64Value", + "Int32Value", + "UInt32Value", + "BoolValue", + "StringValue", + "BytesValue", + ].includes(name.substring(16))); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/clone.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/clone.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1bb50b69734ac61a48a364f40cfb0c598443ae1c --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/clone.d.ts @@ -0,0 +1,6 @@ +import type { MessageShape } from "./types.js"; +import { type DescMessage } from "./descriptors.js"; +/** + * Create a deep copy of a message, including extensions and unknown fields. + */ +export declare function clone(schema: Desc, message: MessageShape): MessageShape; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/clone.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/clone.js new file mode 100644 index 0000000000000000000000000000000000000000..a85b07c813c995ebff2164c133540eea0ca4dfba --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/clone.js @@ -0,0 +1,63 @@ +// Copyright 2021-2025 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. +import { ScalarType } from "./descriptors.js"; +import { reflect } from "./reflect/reflect.js"; +import { isReflectMessage } from "./reflect/guard.js"; +/** + * Create a deep copy of a message, including extensions and unknown fields. + */ +export function clone(schema, message) { + return cloneReflect(reflect(schema, message)).message; +} +function cloneReflect(i) { + const o = reflect(i.desc); + for (const f of i.fields) { + if (!i.isSet(f)) { + continue; + } + switch (f.fieldKind) { + case "list": + const list = o.get(f); + for (const item of i.get(f)) { + list.add(cloneSingular(f, item)); + } + break; + case "map": + const map = o.get(f); + for (const entry of i.get(f).entries()) { + map.set(entry[0], cloneSingular(f, entry[1])); + } + break; + default: { + o.set(f, cloneSingular(f, i.get(f))); + break; + } + } + } + const unknown = i.getUnknown(); + if (unknown && unknown.length > 0) { + o.setUnknown([...unknown]); + } + return o; +} +function cloneSingular(field, value) { + if (field.message !== undefined && isReflectMessage(value)) { + return cloneReflect(value); + } + if (field.scalar == ScalarType.BYTES && value instanceof Uint8Array) { + // @ts-expect-error T cannot extend Uint8Array in practice + return value.slice(); + } + return value; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/enum.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/enum.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8f5c83a3180972742186b1cb625525c1d051e3ae --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/enum.d.ts @@ -0,0 +1,10 @@ +import type { DescFile } from "../descriptors.js"; +import type { GenEnum } from "./types.js"; +import type { JsonValue } from "../json-value.js"; +export { tsEnum } from "../codegenv2/enum.js"; +/** + * Hydrate an enum descriptor. + * + * @private + */ +export declare function enumDesc(file: DescFile, path: number, ...paths: number[]): GenEnum; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/enum.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/enum.js new file mode 100644 index 0000000000000000000000000000000000000000..c9c337b394e0d7711bd1bf4456d856c466eddb3d --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/enum.js @@ -0,0 +1,26 @@ +// Copyright 2021-2025 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. +export { tsEnum } from "../codegenv2/enum.js"; +/** + * Hydrate an enum descriptor. + * + * @private + */ +export function enumDesc(file, path, ...paths) { + if (paths.length == 0) { + return file.enums[path]; + } + const e = paths.pop(); // we checked length above + return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]).nestedEnums[e]; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/extension.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/extension.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7d6374bcec186a977ddacd246b40d85b3eff055b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/extension.d.ts @@ -0,0 +1,9 @@ +import type { Message } from "../types.js"; +import type { DescFile } from "../descriptors.js"; +import type { GenExtension } from "./types.js"; +/** + * Hydrate an extension descriptor. + * + * @private + */ +export declare function extDesc(file: DescFile, path: number, ...paths: number[]): GenExtension; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/extension.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/extension.js new file mode 100644 index 0000000000000000000000000000000000000000..de24b25b36ff4897872f67433b6b0bc5bae37d92 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/extension.js @@ -0,0 +1,25 @@ +// Copyright 2021-2025 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. +/** + * Hydrate an extension descriptor. + * + * @private + */ +export function extDesc(file, path, ...paths) { + if (paths.length == 0) { + return file.extensions[path]; + } + const e = paths.pop(); // we checked length above + return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]).nestedExtensions[e]; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/file.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/file.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5c3a5130ba3660c6e1d60292a17fb9a2b1036e23 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/file.d.ts @@ -0,0 +1 @@ +export { fileDesc } from "../codegenv2/file.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/file.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/file.js new file mode 100644 index 0000000000000000000000000000000000000000..edc74481de9921456103a017564ca3dd41d31dc0 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/file.js @@ -0,0 +1,14 @@ +// Copyright 2021-2025 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. +export { fileDesc } from "../codegenv2/file.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/index.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a3f2ade756d461c31c5241dda3f62d2974f2a39c --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/index.d.ts @@ -0,0 +1,10 @@ +export * from "../codegenv2/boot.js"; +export * from "../codegenv2/embed.js"; +export * from "./enum.js"; +export * from "./extension.js"; +export * from "./file.js"; +export * from "./message.js"; +export * from "./service.js"; +export * from "./symbols.js"; +export * from "../codegenv2/scalar.js"; +export * from "./types.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/index.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/index.js new file mode 100644 index 0000000000000000000000000000000000000000..edf3a3c13e73062daebf2671a24d8a9287a04620 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/index.js @@ -0,0 +1,23 @@ +// Copyright 2021-2025 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. +export * from "../codegenv2/boot.js"; +export * from "../codegenv2/embed.js"; +export * from "./enum.js"; +export * from "./extension.js"; +export * from "./file.js"; +export * from "./message.js"; +export * from "./service.js"; +export * from "./symbols.js"; +export * from "../codegenv2/scalar.js"; +export * from "./types.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/message.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/message.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..46ad4ad1ce7d510cfcf5b28dfd8b26563bc7d6e2 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/message.d.ts @@ -0,0 +1,10 @@ +import type { Message } from "../types.js"; +import type { DescFile } from "../descriptors.js"; +import type { GenMessage } from "./types.js"; +import type { JsonValue } from "../json-value.js"; +/** + * Hydrate a message descriptor. + * + * @private + */ +export declare function messageDesc(file: DescFile, path: number, ...paths: number[]): GenMessage; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/message.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/message.js new file mode 100644 index 0000000000000000000000000000000000000000..adc2f559d89731e695f2fb56c6b5e1e7d36da845 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/message.js @@ -0,0 +1,21 @@ +// Copyright 2021-2025 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. +/** + * Hydrate a message descriptor. + * + * @private + */ +export function messageDesc(file, path, ...paths) { + return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/service.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/service.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5818f75d547bf0b73e1da8d26ffb7e3f48bfa3f3 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/service.d.ts @@ -0,0 +1,8 @@ +import type { GenService, GenServiceMethods } from "./types.js"; +import type { DescFile } from "../descriptors.js"; +/** + * Hydrate a service descriptor. + * + * @private + */ +export declare function serviceDesc(file: DescFile, path: number, ...paths: number[]): GenService; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/service.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/service.js new file mode 100644 index 0000000000000000000000000000000000000000..e5684e07ddd8689ef72479763232529365ffb31a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/service.js @@ -0,0 +1,24 @@ +// Copyright 2021-2025 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. +/** + * Hydrate a service descriptor. + * + * @private + */ +export function serviceDesc(file, path, ...paths) { + if (paths.length > 0) { + throw new Error(); + } + return file.services[path]; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/symbols.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/symbols.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..fb9fd70ebddb4bafa7cca7e3479564ababb5db3a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/symbols.d.ts @@ -0,0 +1,135 @@ +/** + * @private + */ +export declare const packageName = "@bufbuild/protobuf"; +/** + * @private + */ +export declare const wktPublicImportPaths: Readonly>; +/** + * @private + */ +export declare const symbols: { + readonly codegen: { + readonly boot: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv1/boot.js"; + readonly from: string; + }; + readonly fileDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv1/file.js"; + readonly from: string; + }; + readonly enumDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv1/enum.js"; + readonly from: string; + }; + readonly extDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv1/extension.js"; + readonly from: string; + }; + readonly messageDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv1/message.js"; + readonly from: string; + }; + readonly serviceDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv1/service.js"; + readonly from: string; + }; + readonly tsEnum: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv1/enum.js"; + readonly from: string; + }; + readonly GenFile: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv1/types.js"; + readonly from: string; + }; + readonly GenEnum: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv1/types.js"; + readonly from: string; + }; + readonly GenExtension: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv1/types.js"; + readonly from: string; + }; + readonly GenMessage: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv1/types.js"; + readonly from: string; + }; + readonly GenService: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv1/types.js"; + readonly from: string; + }; + }; + readonly isMessage: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../is-message.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly Message: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../types.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly create: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../create.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly fromJson: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../from-json.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly fromJsonString: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../from-json.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly fromBinary: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../from-binary.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly toBinary: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../to-binary.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly toJson: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../to-json.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly toJsonString: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../to-json.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly protoInt64: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../proto-int64.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly JsonValue: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../json-value.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly JsonObject: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../json-value.js"; + readonly from: "@bufbuild/protobuf"; + }; +}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/symbols.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/symbols.js new file mode 100644 index 0000000000000000000000000000000000000000..d4403bcaa81c5c49a9cd7976d4ceb1eebd7142c5 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/symbols.js @@ -0,0 +1,40 @@ +// Copyright 2021-2025 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. +import { symbols as symbolsV2, packageName as packageNameV1, wktPublicImportPaths as wktPublicImportPathsV2, } from "../codegenv2/symbols.js"; +/** + * @private + */ +export const packageName = packageNameV1; +/** + * @private + */ +export const wktPublicImportPaths = wktPublicImportPathsV2; +/** + * @private + */ +// biome-ignore format: want this to read well +export const symbols = Object.assign(Object.assign({}, symbolsV2), { codegen: { + boot: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/boot.js", from: packageName + "/codegenv1" }, + fileDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/file.js", from: packageName + "/codegenv1" }, + enumDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/enum.js", from: packageName + "/codegenv1" }, + extDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/extension.js", from: packageName + "/codegenv1" }, + messageDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/message.js", from: packageName + "/codegenv1" }, + serviceDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/service.js", from: packageName + "/codegenv1" }, + tsEnum: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/enum.js", from: packageName + "/codegenv1" }, + GenFile: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: packageName + "/codegenv1" }, + GenEnum: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: packageName + "/codegenv1" }, + GenExtension: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: packageName + "/codegenv1" }, + GenMessage: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: packageName + "/codegenv1" }, + GenService: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: packageName + "/codegenv1" }, + } }); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/types.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/types.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8060fade67e8af9aa0f08e45322149a13e9a7d31 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/types.d.ts @@ -0,0 +1,75 @@ +import type { Message } from "../types.js"; +import type { DescEnum, DescEnumValue, DescExtension, DescField, DescFile, DescMessage, DescMethod, DescService } from "../descriptors.js"; +import type { JsonValue } from "../json-value.js"; +/** + * Describes a protobuf source file. + * + * @private + */ +export type GenFile = DescFile; +/** + * Describes a message declaration in a protobuf source file. + * + * This type is identical to DescMessage, but carries additional type + * information. + * + * @private + */ +export type GenMessage = Omit & { + field: Record, DescField>; + typeName: RuntimeShape["$typeName"]; +} & brandv1; +/** + * Describes an enumeration in a protobuf source file. + * + * This type is identical to DescEnum, but carries additional type + * information. + * + * @private + */ +export type GenEnum = Omit & { + value: Record; +} & brandv1; +/** + * Describes an extension in a protobuf source file. + * + * This type is identical to DescExtension, but carries additional type + * information. + * + * @private + */ +export type GenExtension = DescExtension & brandv1; +/** + * Describes a service declaration in a protobuf source file. + * + * This type is identical to DescService, but carries additional type + * information. + * + * @private + */ +export type GenService = Omit & { + method: { + [K in keyof RuntimeShape]: RuntimeShape[K] & DescMethod; + }; +}; +/** + * @private + */ +export type GenServiceMethods = Record>; +declare class brandv1 { + protected v: "codegenv1"; + protected a: A | boolean; + protected b: B | boolean; +} +/** + * Union of the property names of all fields, including oneof members. + * For an anonymous message (no generated message shape), it's simply a string. + */ +type MessageFieldNames = Message extends T ? string : Exclude ? K : P]-?: true; +}, number | symbol>; +type Oneof = { + case: K | undefined; + value?: unknown; +}; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/types.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/types.js new file mode 100644 index 0000000000000000000000000000000000000000..5877ef744f2df2f38aed7bb4ecc05142f7520bff --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv1/types.js @@ -0,0 +1,21 @@ +// Copyright 2021-2025 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. +class brandv1 { + constructor() { + this.v = "codegenv1"; + this.a = false; + this.b = false; + } +} +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/boot.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/boot.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3edbb6c59bb896576a37c27a11a1f2882b902aa4 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/boot.d.ts @@ -0,0 +1,63 @@ +import type { DescriptorProto_ExtensionRange, FieldDescriptorProto_Label, FieldDescriptorProto_Type, FieldOptions_OptionRetention, FieldOptions_OptionTargetType, FieldOptions_EditionDefault, EnumValueDescriptorProto, FileDescriptorProto } from "../wkt/gen/google/protobuf/descriptor_pb.js"; +import type { DescFile } from "../descriptors.js"; +/** + * Hydrate a file descriptor for google/protobuf/descriptor.proto from a plain + * object. + * + * See createFileDescriptorProtoBoot() for details. + * + * @private + */ +export declare function boot(boot: FileDescriptorProtoBoot): DescFile; +/** + * An object literal for initializing the message google.protobuf.FileDescriptorProto + * for google/protobuf/descriptor.proto. + * + * See createFileDescriptorProtoBoot() for details. + * + * @private + */ +export type FileDescriptorProtoBoot = { + name: "google/protobuf/descriptor.proto"; + package: "google.protobuf"; + messageType: DescriptorProtoBoot[]; + enumType: EnumDescriptorProtoBoot[]; +}; +export type DescriptorProtoBoot = { + name: string; + field?: FieldDescriptorProtoBoot[]; + nestedType?: DescriptorProtoBoot[]; + enumType?: EnumDescriptorProtoBoot[]; + extensionRange?: Pick[]; +}; +export type FieldDescriptorProtoBoot = { + name: string; + number: number; + label?: FieldDescriptorProto_Label; + type: FieldDescriptorProto_Type; + typeName?: string; + extendee?: string; + defaultValue?: string; + options?: FieldOptionsBoot; +}; +export type FieldOptionsBoot = { + packed?: boolean; + deprecated?: boolean; + retention?: FieldOptions_OptionRetention; + targets?: FieldOptions_OptionTargetType[]; + editionDefaults?: FieldOptions_EditionDefaultBoot[]; +}; +export type FieldOptions_EditionDefaultBoot = Pick; +export type EnumDescriptorProtoBoot = { + name: string; + value: EnumValueDescriptorProtoBoot[]; +}; +export type EnumValueDescriptorProtoBoot = Pick; +/** + * Creates the message google.protobuf.FileDescriptorProto from an object literal. + * + * See createFileDescriptorProtoBoot() for details. + * + * @private + */ +export declare function bootFileDescriptorProto(init: FileDescriptorProtoBoot): FileDescriptorProto; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/boot.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/boot.js new file mode 100644 index 0000000000000000000000000000000000000000..65d8654138e0aa85963081d63db2b885add46405 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/boot.js @@ -0,0 +1,101 @@ +// Copyright 2021-2025 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. +import { restoreJsonNames } from "./restore-json-names.js"; +import { createFileRegistry } from "../registry.js"; +/** + * Hydrate a file descriptor for google/protobuf/descriptor.proto from a plain + * object. + * + * See createFileDescriptorProtoBoot() for details. + * + * @private + */ +export function boot(boot) { + const root = bootFileDescriptorProto(boot); + root.messageType.forEach(restoreJsonNames); + const reg = createFileRegistry(root, () => undefined); + // biome-ignore lint/style/noNonNullAssertion: non-null assertion because we just created the registry from the file we look up + return reg.getFile(root.name); +} +/** + * Creates the message google.protobuf.FileDescriptorProto from an object literal. + * + * See createFileDescriptorProtoBoot() for details. + * + * @private + */ +export function bootFileDescriptorProto(init) { + const proto = Object.create({ + syntax: "", + edition: 0, + }); + return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FileDescriptorProto", dependency: [], publicDependency: [], weakDependency: [], optionDependency: [], service: [], extension: [] }, init), { messageType: init.messageType.map(bootDescriptorProto), enumType: init.enumType.map(bootEnumDescriptorProto) })); +} +function bootDescriptorProto(init) { + var _a, _b, _c, _d, _e, _f, _g, _h; + const proto = Object.create({ + visibility: 0, + }); + return Object.assign(proto, { + $typeName: "google.protobuf.DescriptorProto", + name: init.name, + field: (_b = (_a = init.field) === null || _a === void 0 ? void 0 : _a.map(bootFieldDescriptorProto)) !== null && _b !== void 0 ? _b : [], + extension: [], + nestedType: (_d = (_c = init.nestedType) === null || _c === void 0 ? void 0 : _c.map(bootDescriptorProto)) !== null && _d !== void 0 ? _d : [], + enumType: (_f = (_e = init.enumType) === null || _e === void 0 ? void 0 : _e.map(bootEnumDescriptorProto)) !== null && _f !== void 0 ? _f : [], + extensionRange: (_h = (_g = init.extensionRange) === null || _g === void 0 ? void 0 : _g.map((e) => (Object.assign({ $typeName: "google.protobuf.DescriptorProto.ExtensionRange" }, e)))) !== null && _h !== void 0 ? _h : [], + oneofDecl: [], + reservedRange: [], + reservedName: [], + }); +} +function bootFieldDescriptorProto(init) { + const proto = Object.create({ + label: 1, + typeName: "", + extendee: "", + defaultValue: "", + oneofIndex: 0, + jsonName: "", + proto3Optional: false, + }); + return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FieldDescriptorProto" }, init), { options: init.options ? bootFieldOptions(init.options) : undefined })); +} +function bootFieldOptions(init) { + var _a, _b, _c; + const proto = Object.create({ + ctype: 0, + packed: false, + jstype: 0, + lazy: false, + unverifiedLazy: false, + deprecated: false, + weak: false, + debugRedact: false, + retention: 0, + }); + return Object.assign(proto, Object.assign(Object.assign({ $typeName: "google.protobuf.FieldOptions" }, init), { targets: (_a = init.targets) !== null && _a !== void 0 ? _a : [], editionDefaults: (_c = (_b = init.editionDefaults) === null || _b === void 0 ? void 0 : _b.map((e) => (Object.assign({ $typeName: "google.protobuf.FieldOptions.EditionDefault" }, e)))) !== null && _c !== void 0 ? _c : [], uninterpretedOption: [] })); +} +function bootEnumDescriptorProto(init) { + const proto = Object.create({ + visibility: 0, + }); + return Object.assign(proto, { + $typeName: "google.protobuf.EnumDescriptorProto", + name: init.name, + reservedName: [], + reservedRange: [], + value: init.value.map((e) => (Object.assign({ $typeName: "google.protobuf.EnumValueDescriptorProto" }, e))), + }); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/embed.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/embed.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a0feea1d86b5320d105d316e2df67777a9c7ddf9 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/embed.d.ts @@ -0,0 +1,43 @@ +import type { DescEnum, DescExtension, DescMessage, DescService } from "../descriptors.js"; +import { type FileDescriptorProto } from "../wkt/gen/google/protobuf/descriptor_pb.js"; +import type { FileDescriptorProtoBoot } from "./boot.js"; +type EmbedUnknown = { + bootable: false; + proto(): FileDescriptorProto; + base64(): string; +}; +type EmbedDescriptorProto = Omit & { + bootable: true; + boot(): FileDescriptorProtoBoot; +}; +/** + * Create necessary information to embed a file descriptor in + * generated code. + * + * @private + */ +export declare function embedFileDesc(file: FileDescriptorProto): EmbedUnknown | EmbedDescriptorProto; +/** + * Compute the path to a message, enumeration, extension, or service in a + * file descriptor. + * + * @private + */ +export declare function pathInFileDesc(desc: DescMessage | DescEnum | DescExtension | DescService): number[]; +/** + * The file descriptor for google/protobuf/descriptor.proto cannot be embedded + * in serialized form, since it is required to parse itself. + * + * This function takes an instance of the message, and returns a plain object + * that can be hydrated to the message again via bootFileDescriptorProto(). + * + * This function only works with a message google.protobuf.FileDescriptorProto + * for google/protobuf/descriptor.proto, and only supports features that are + * relevant for the specific use case. For example, it discards file options, + * reserved ranges and reserved names, and field options that are unused in + * descriptor.proto. + * + * @private + */ +export declare function createFileDescriptorProtoBoot(proto: FileDescriptorProto): FileDescriptorProtoBoot; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/embed.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/embed.js new file mode 100644 index 0000000000000000000000000000000000000000..1dfa604b440a5c56f0e1cdfec8da73da0d35e82f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/embed.js @@ -0,0 +1,239 @@ +// Copyright 2021-2025 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. +import { protoCamelCase } from "../reflect/names.js"; +import { isFieldSet, clearField } from "../fields.js"; +import { base64Encode } from "../wire/base64-encoding.js"; +import { toBinary } from "../to-binary.js"; +import { clone } from "../clone.js"; +import { Edition, FieldDescriptorProtoSchema, FieldOptionsSchema, FileDescriptorProtoSchema, DescriptorProtoSchema, EnumDescriptorProtoSchema, } from "../wkt/gen/google/protobuf/descriptor_pb.js"; +/** + * Create necessary information to embed a file descriptor in + * generated code. + * + * @private + */ +export function embedFileDesc(file) { + const embed = { + bootable: false, + proto() { + const stripped = clone(FileDescriptorProtoSchema, file); + clearField(stripped, FileDescriptorProtoSchema.field.dependency); + clearField(stripped, FileDescriptorProtoSchema.field.sourceCodeInfo); + stripped.messageType.map(stripJsonNames); + return stripped; + }, + base64() { + const bytes = toBinary(FileDescriptorProtoSchema, this.proto()); + return base64Encode(bytes, "std_raw"); + }, + }; + return file.name == "google/protobuf/descriptor.proto" + ? Object.assign(Object.assign({}, embed), { bootable: true, boot() { + return createFileDescriptorProtoBoot(this.proto()); + } }) : embed; +} +function stripJsonNames(d) { + for (const f of d.field) { + if (f.jsonName === protoCamelCase(f.name)) { + clearField(f, FieldDescriptorProtoSchema.field.jsonName); + } + } + for (const n of d.nestedType) { + stripJsonNames(n); + } +} +/** + * Compute the path to a message, enumeration, extension, or service in a + * file descriptor. + * + * @private + */ +export function pathInFileDesc(desc) { + if (desc.kind == "service") { + return [desc.file.services.indexOf(desc)]; + } + const parent = desc.parent; + if (parent == undefined) { + switch (desc.kind) { + case "enum": + return [desc.file.enums.indexOf(desc)]; + case "message": + return [desc.file.messages.indexOf(desc)]; + case "extension": + return [desc.file.extensions.indexOf(desc)]; + } + } + function findPath(cur) { + const nested = []; + for (let parent = cur.parent; parent;) { + const idx = parent.nestedMessages.indexOf(cur); + nested.unshift(idx); + cur = parent; + parent = cur.parent; + } + nested.unshift(cur.file.messages.indexOf(cur)); + return nested; + } + const path = findPath(parent); + switch (desc.kind) { + case "extension": + return [...path, parent.nestedExtensions.indexOf(desc)]; + case "message": + return [...path, parent.nestedMessages.indexOf(desc)]; + case "enum": + return [...path, parent.nestedEnums.indexOf(desc)]; + } +} +/** + * The file descriptor for google/protobuf/descriptor.proto cannot be embedded + * in serialized form, since it is required to parse itself. + * + * This function takes an instance of the message, and returns a plain object + * that can be hydrated to the message again via bootFileDescriptorProto(). + * + * This function only works with a message google.protobuf.FileDescriptorProto + * for google/protobuf/descriptor.proto, and only supports features that are + * relevant for the specific use case. For example, it discards file options, + * reserved ranges and reserved names, and field options that are unused in + * descriptor.proto. + * + * @private + */ +export function createFileDescriptorProtoBoot(proto) { + var _a; + assert(proto.name == "google/protobuf/descriptor.proto"); + assert(proto.package == "google.protobuf"); + assert(!proto.dependency.length); + assert(!proto.publicDependency.length); + assert(!proto.weakDependency.length); + assert(!proto.optionDependency.length); + assert(!proto.service.length); + assert(!proto.extension.length); + assert(proto.sourceCodeInfo === undefined); + assert(proto.syntax == "" || proto.syntax == "proto2"); + assert(!((_a = proto.options) === null || _a === void 0 ? void 0 : _a.features)); // we're dropping file options + assert(proto.edition === Edition.EDITION_UNKNOWN); + return { + name: proto.name, + package: proto.package, + messageType: proto.messageType.map(createDescriptorBoot), + enumType: proto.enumType.map(createEnumDescriptorBoot), + }; +} +function createDescriptorBoot(proto) { + assert(proto.extension.length == 0); + assert(!proto.oneofDecl.length); + assert(!proto.options); + assert(!isFieldSet(proto, DescriptorProtoSchema.field.visibility)); + const b = { + name: proto.name, + }; + if (proto.field.length) { + b.field = proto.field.map(createFieldDescriptorBoot); + } + if (proto.nestedType.length) { + b.nestedType = proto.nestedType.map(createDescriptorBoot); + } + if (proto.enumType.length) { + b.enumType = proto.enumType.map(createEnumDescriptorBoot); + } + if (proto.extensionRange.length) { + b.extensionRange = proto.extensionRange.map((r) => { + assert(!r.options); + return { start: r.start, end: r.end }; + }); + } + return b; +} +function createFieldDescriptorBoot(proto) { + assert(isFieldSet(proto, FieldDescriptorProtoSchema.field.name)); + assert(isFieldSet(proto, FieldDescriptorProtoSchema.field.number)); + assert(isFieldSet(proto, FieldDescriptorProtoSchema.field.type)); + assert(!isFieldSet(proto, FieldDescriptorProtoSchema.field.oneofIndex)); + assert(!isFieldSet(proto, FieldDescriptorProtoSchema.field.jsonName) || + proto.jsonName === protoCamelCase(proto.name)); + const b = { + name: proto.name, + number: proto.number, + type: proto.type, + }; + if (isFieldSet(proto, FieldDescriptorProtoSchema.field.label)) { + b.label = proto.label; + } + if (isFieldSet(proto, FieldDescriptorProtoSchema.field.typeName)) { + b.typeName = proto.typeName; + } + if (isFieldSet(proto, FieldDescriptorProtoSchema.field.extendee)) { + b.extendee = proto.extendee; + } + if (isFieldSet(proto, FieldDescriptorProtoSchema.field.defaultValue)) { + b.defaultValue = proto.defaultValue; + } + if (proto.options) { + b.options = createFieldOptionsBoot(proto.options); + } + return b; +} +function createFieldOptionsBoot(proto) { + const b = {}; + assert(!isFieldSet(proto, FieldOptionsSchema.field.ctype)); + if (isFieldSet(proto, FieldOptionsSchema.field.packed)) { + b.packed = proto.packed; + } + assert(!isFieldSet(proto, FieldOptionsSchema.field.jstype)); + assert(!isFieldSet(proto, FieldOptionsSchema.field.lazy)); + assert(!isFieldSet(proto, FieldOptionsSchema.field.unverifiedLazy)); + if (isFieldSet(proto, FieldOptionsSchema.field.deprecated)) { + b.deprecated = proto.deprecated; + } + assert(!isFieldSet(proto, FieldOptionsSchema.field.weak)); + assert(!isFieldSet(proto, FieldOptionsSchema.field.debugRedact)); + if (isFieldSet(proto, FieldOptionsSchema.field.retention)) { + b.retention = proto.retention; + } + if (proto.targets.length) { + b.targets = proto.targets; + } + if (proto.editionDefaults.length) { + b.editionDefaults = proto.editionDefaults.map((d) => ({ + value: d.value, + edition: d.edition, + })); + } + assert(!isFieldSet(proto, FieldOptionsSchema.field.features)); + assert(!isFieldSet(proto, FieldOptionsSchema.field.uninterpretedOption)); + return b; +} +function createEnumDescriptorBoot(proto) { + assert(!proto.options); + assert(!isFieldSet(proto, EnumDescriptorProtoSchema.field.visibility)); + return { + name: proto.name, + value: proto.value.map((v) => { + assert(!v.options); + return { + name: v.name, + number: v.number, + }; + }), + }; +} +/** + * Assert that condition is truthy or throw error. + */ +function assert(condition) { + if (!condition) { + throw new Error(); + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/enum.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/enum.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e77b8fe2c555c39ee298558465124cc6d852c74f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/enum.d.ts @@ -0,0 +1,18 @@ +import type { DescEnum, DescFile } from "../descriptors.js"; +import type { GenEnum } from "./types.js"; +import type { JsonValue } from "../json-value.js"; +/** + * Hydrate an enum descriptor. + * + * @private + */ +export declare function enumDesc(file: DescFile, path: number, ...paths: number[]): GenEnum; +/** + * Construct a TypeScript enum object at runtime from a descriptor. + */ +export declare function tsEnum(desc: DescEnum): enumObject; +type enumObject = { + [key: number]: string; + [k: string]: number | string; +}; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/enum.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/enum.js new file mode 100644 index 0000000000000000000000000000000000000000..92351651d3ed6b677c28b982d0d811cc0f4bf64e --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/enum.js @@ -0,0 +1,36 @@ +// Copyright 2021-2025 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. +/** + * Hydrate an enum descriptor. + * + * @private + */ +export function enumDesc(file, path, ...paths) { + if (paths.length == 0) { + return file.enums[path]; + } + const e = paths.pop(); // we checked length above + return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]).nestedEnums[e]; +} +/** + * Construct a TypeScript enum object at runtime from a descriptor. + */ +export function tsEnum(desc) { + const enumObject = {}; + for (const value of desc.values) { + enumObject[value.localName] = value.number; + enumObject[value.number] = value.localName; + } + return enumObject; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/extension.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/extension.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7d6374bcec186a977ddacd246b40d85b3eff055b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/extension.d.ts @@ -0,0 +1,9 @@ +import type { Message } from "../types.js"; +import type { DescFile } from "../descriptors.js"; +import type { GenExtension } from "./types.js"; +/** + * Hydrate an extension descriptor. + * + * @private + */ +export declare function extDesc(file: DescFile, path: number, ...paths: number[]): GenExtension; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/extension.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/extension.js new file mode 100644 index 0000000000000000000000000000000000000000..de24b25b36ff4897872f67433b6b0bc5bae37d92 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/extension.js @@ -0,0 +1,25 @@ +// Copyright 2021-2025 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. +/** + * Hydrate an extension descriptor. + * + * @private + */ +export function extDesc(file, path, ...paths) { + if (paths.length == 0) { + return file.extensions[path]; + } + const e = paths.pop(); // we checked length above + return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]).nestedExtensions[e]; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/file.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/file.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4d9853f347c363a6643e4a7cacba1afbf7ff9065 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/file.d.ts @@ -0,0 +1,7 @@ +import type { DescFile } from "../descriptors.js"; +/** + * Hydrate a file descriptor. + * + * @private + */ +export declare function fileDesc(b64: string, imports?: DescFile[]): DescFile; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/file.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/file.js new file mode 100644 index 0000000000000000000000000000000000000000..55e34c03507315207ca0e77d04808ee109605328 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/file.js @@ -0,0 +1,32 @@ +// Copyright 2021-2025 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. +import { base64Decode } from "../wire/base64-encoding.js"; +import { FileDescriptorProtoSchema } from "../wkt/gen/google/protobuf/descriptor_pb.js"; +import { createFileRegistry } from "../registry.js"; +import { restoreJsonNames } from "./restore-json-names.js"; +import { fromBinary } from "../from-binary.js"; +/** + * Hydrate a file descriptor. + * + * @private + */ +export function fileDesc(b64, imports) { + var _a; + const root = fromBinary(FileDescriptorProtoSchema, base64Decode(b64)); + root.messageType.forEach(restoreJsonNames); + root.dependency = (_a = imports === null || imports === void 0 ? void 0 : imports.map((f) => f.proto.name)) !== null && _a !== void 0 ? _a : []; + const reg = createFileRegistry(root, (protoFileName) => imports === null || imports === void 0 ? void 0 : imports.find((f) => f.proto.name === protoFileName)); + // biome-ignore lint/style/noNonNullAssertion: non-null assertion because we just created the registry from the file we look up + return reg.getFile(root.name); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/index.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b74cd36f7e476b9fbbd83cd0a9e78f8769513a4b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/index.d.ts @@ -0,0 +1,10 @@ +export * from "./boot.js"; +export * from "./embed.js"; +export * from "./enum.js"; +export * from "./extension.js"; +export * from "./file.js"; +export * from "./message.js"; +export * from "./service.js"; +export * from "./symbols.js"; +export * from "./scalar.js"; +export * from "./types.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/index.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/index.js new file mode 100644 index 0000000000000000000000000000000000000000..4b6fc99fb520635134cf644262e665d4ee46f54f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/index.js @@ -0,0 +1,23 @@ +// Copyright 2021-2025 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. +export * from "./boot.js"; +export * from "./embed.js"; +export * from "./enum.js"; +export * from "./extension.js"; +export * from "./file.js"; +export * from "./message.js"; +export * from "./service.js"; +export * from "./symbols.js"; +export * from "./scalar.js"; +export * from "./types.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/message.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/message.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f0f39779d7b5ec4ac7b4ffc534c6ccd43103fec4 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/message.d.ts @@ -0,0 +1,15 @@ +import type { Message } from "../types.js"; +import type { DescFile } from "../descriptors.js"; +import type { GenMessage } from "./types.js"; +/** + * Hydrate a message descriptor. + * + * @private + */ +export declare function messageDesc(file: DescFile, path: number, ...paths: number[]): GenMessage; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/message.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/message.js new file mode 100644 index 0000000000000000000000000000000000000000..adc2f559d89731e695f2fb56c6b5e1e7d36da845 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/message.js @@ -0,0 +1,21 @@ +// Copyright 2021-2025 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. +/** + * Hydrate a message descriptor. + * + * @private + */ +export function messageDesc(file, path, ...paths) { + return paths.reduce((acc, cur) => acc.nestedMessages[cur], file.messages[path]); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/restore-json-names.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/restore-json-names.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d83d94ddc311c79dd96b46bbca4a6764f7dd1a5f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/restore-json-names.d.ts @@ -0,0 +1,5 @@ +import type { DescriptorProto } from "../wkt/gen/google/protobuf/descriptor_pb.js"; +/** + * @private + */ +export declare function restoreJsonNames(message: DescriptorProto): void; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/restore-json-names.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/restore-json-names.js new file mode 100644 index 0000000000000000000000000000000000000000..26e48ae177a8445d3015ae5f5f31568fe01cb87f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/restore-json-names.js @@ -0,0 +1,26 @@ +// Copyright 2021-2025 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. +import { protoCamelCase } from "../reflect/names.js"; +import { unsafeIsSetExplicit } from "../reflect/unsafe.js"; +/** + * @private + */ +export function restoreJsonNames(message) { + for (const f of message.field) { + if (!unsafeIsSetExplicit(f, "jsonName")) { + f.jsonName = protoCamelCase(f.name); + } + } + message.nestedType.forEach(restoreJsonNames); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/scalar.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/scalar.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5c48fceb954d6519008f19054fc1932e8b09ab57 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/scalar.d.ts @@ -0,0 +1,9 @@ +import { ScalarType } from "../descriptors.js"; +/** + * Return the TypeScript type (as a string) for the given scalar type. + */ +export declare function scalarTypeScriptType(scalar: ScalarType, longAsString: boolean): "string" | "boolean" | "bigint" | "bigint | string" | "Uint8Array" | "number"; +/** + * Return the JSON type (as a string) for the given scalar type. + */ +export declare function scalarJsonType(scalar: ScalarType): "string" | "boolean" | "number" | `number | "NaN" | "Infinity" | "-Infinity"`; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/scalar.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/scalar.js new file mode 100644 index 0000000000000000000000000000000000000000..e45b37e059d06eb69ca9bbea5da0f2798bae1e5e --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/scalar.js @@ -0,0 +1,63 @@ +// Copyright 2021-2025 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. +import { ScalarType } from "../descriptors.js"; +/** + * Return the TypeScript type (as a string) for the given scalar type. + */ +export function scalarTypeScriptType(scalar, longAsString) { + switch (scalar) { + case ScalarType.STRING: + return "string"; + case ScalarType.BOOL: + return "boolean"; + case ScalarType.UINT64: + case ScalarType.SFIXED64: + case ScalarType.FIXED64: + case ScalarType.SINT64: + case ScalarType.INT64: + return longAsString ? "string" : "bigint"; + case ScalarType.BYTES: + return "Uint8Array"; + default: + return "number"; + } +} +/** + * Return the JSON type (as a string) for the given scalar type. + */ +export function scalarJsonType(scalar) { + switch (scalar) { + case ScalarType.DOUBLE: + case ScalarType.FLOAT: + return `number | "NaN" | "Infinity" | "-Infinity"`; + case ScalarType.UINT64: + case ScalarType.SFIXED64: + case ScalarType.FIXED64: + case ScalarType.SINT64: + case ScalarType.INT64: + return "string"; + case ScalarType.INT32: + case ScalarType.FIXED32: + case ScalarType.UINT32: + case ScalarType.SFIXED32: + case ScalarType.SINT32: + return "number"; + case ScalarType.STRING: + return "string"; + case ScalarType.BOOL: + return "boolean"; + case ScalarType.BYTES: + return "string"; + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/service.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/service.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5818f75d547bf0b73e1da8d26ffb7e3f48bfa3f3 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/service.d.ts @@ -0,0 +1,8 @@ +import type { GenService, GenServiceMethods } from "./types.js"; +import type { DescFile } from "../descriptors.js"; +/** + * Hydrate a service descriptor. + * + * @private + */ +export declare function serviceDesc(file: DescFile, path: number, ...paths: number[]): GenService; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/service.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/service.js new file mode 100644 index 0000000000000000000000000000000000000000..e5684e07ddd8689ef72479763232529365ffb31a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/service.js @@ -0,0 +1,24 @@ +// Copyright 2021-2025 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. +/** + * Hydrate a service descriptor. + * + * @private + */ +export function serviceDesc(file, path, ...paths) { + if (paths.length > 0) { + throw new Error(); + } + return file.services[path]; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/symbols.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/symbols.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f9d850264d92fb00054f6579ea5a8d65dcdcfe05 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/symbols.d.ts @@ -0,0 +1,135 @@ +/** + * @private + */ +export declare const packageName = "@bufbuild/protobuf"; +/** + * @private + */ +export declare const wktPublicImportPaths: Readonly>; +/** + * @private + */ +export declare const symbols: { + readonly isMessage: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../is-message.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly Message: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../types.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly create: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../create.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly fromJson: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../from-json.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly fromJsonString: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../from-json.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly fromBinary: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../from-binary.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly toBinary: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../to-binary.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly toJson: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../to-json.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly toJsonString: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../to-json.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly protoInt64: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../proto-int64.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly JsonValue: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../json-value.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly JsonObject: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../json-value.js"; + readonly from: "@bufbuild/protobuf"; + }; + readonly codegen: { + readonly boot: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv2/boot.js"; + readonly from: string; + }; + readonly fileDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv2/file.js"; + readonly from: string; + }; + readonly enumDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv2/enum.js"; + readonly from: string; + }; + readonly extDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv2/extension.js"; + readonly from: string; + }; + readonly messageDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv2/message.js"; + readonly from: string; + }; + readonly serviceDesc: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv2/service.js"; + readonly from: string; + }; + readonly tsEnum: { + readonly typeOnly: false; + readonly bootstrapWktFrom: "../../codegenv2/enum.js"; + readonly from: string; + }; + readonly GenFile: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv2/types.js"; + readonly from: string; + }; + readonly GenEnum: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv2/types.js"; + readonly from: string; + }; + readonly GenExtension: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv2/types.js"; + readonly from: string; + }; + readonly GenMessage: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv2/types.js"; + readonly from: string; + }; + readonly GenService: { + readonly typeOnly: true; + readonly bootstrapWktFrom: "../../codegenv2/types.js"; + readonly from: string; + }; + }; +}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/symbols.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/symbols.js new file mode 100644 index 0000000000000000000000000000000000000000..62be0a22f3aaace562e525039219439d5e6e06f9 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/symbols.js @@ -0,0 +1,69 @@ +// Copyright 2021-2025 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. +/** + * @private + */ +export const packageName = "@bufbuild/protobuf"; +/** + * @private + */ +export const wktPublicImportPaths = { + "google/protobuf/compiler/plugin.proto": packageName + "/wkt", + "google/protobuf/any.proto": packageName + "/wkt", + "google/protobuf/api.proto": packageName + "/wkt", + "google/protobuf/cpp_features.proto": packageName + "/wkt", + "google/protobuf/descriptor.proto": packageName + "/wkt", + "google/protobuf/duration.proto": packageName + "/wkt", + "google/protobuf/empty.proto": packageName + "/wkt", + "google/protobuf/field_mask.proto": packageName + "/wkt", + "google/protobuf/go_features.proto": packageName + "/wkt", + "google/protobuf/java_features.proto": packageName + "/wkt", + "google/protobuf/source_context.proto": packageName + "/wkt", + "google/protobuf/struct.proto": packageName + "/wkt", + "google/protobuf/timestamp.proto": packageName + "/wkt", + "google/protobuf/type.proto": packageName + "/wkt", + "google/protobuf/wrappers.proto": packageName + "/wkt", +}; +/** + * @private + */ +// biome-ignore format: want this to read well +export const symbols = { + isMessage: { typeOnly: false, bootstrapWktFrom: "../../is-message.js", from: packageName }, + Message: { typeOnly: true, bootstrapWktFrom: "../../types.js", from: packageName }, + create: { typeOnly: false, bootstrapWktFrom: "../../create.js", from: packageName }, + fromJson: { typeOnly: false, bootstrapWktFrom: "../../from-json.js", from: packageName }, + fromJsonString: { typeOnly: false, bootstrapWktFrom: "../../from-json.js", from: packageName }, + fromBinary: { typeOnly: false, bootstrapWktFrom: "../../from-binary.js", from: packageName }, + toBinary: { typeOnly: false, bootstrapWktFrom: "../../to-binary.js", from: packageName }, + toJson: { typeOnly: false, bootstrapWktFrom: "../../to-json.js", from: packageName }, + toJsonString: { typeOnly: false, bootstrapWktFrom: "../../to-json.js", from: packageName }, + protoInt64: { typeOnly: false, bootstrapWktFrom: "../../proto-int64.js", from: packageName }, + JsonValue: { typeOnly: true, bootstrapWktFrom: "../../json-value.js", from: packageName }, + JsonObject: { typeOnly: true, bootstrapWktFrom: "../../json-value.js", from: packageName }, + codegen: { + boot: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/boot.js", from: packageName + "/codegenv2" }, + fileDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/file.js", from: packageName + "/codegenv2" }, + enumDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/enum.js", from: packageName + "/codegenv2" }, + extDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/extension.js", from: packageName + "/codegenv2" }, + messageDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/message.js", from: packageName + "/codegenv2" }, + serviceDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/service.js", from: packageName + "/codegenv2" }, + tsEnum: { typeOnly: false, bootstrapWktFrom: "../../codegenv2/enum.js", from: packageName + "/codegenv2" }, + GenFile: { typeOnly: true, bootstrapWktFrom: "../../codegenv2/types.js", from: packageName + "/codegenv2" }, + GenEnum: { typeOnly: true, bootstrapWktFrom: "../../codegenv2/types.js", from: packageName + "/codegenv2" }, + GenExtension: { typeOnly: true, bootstrapWktFrom: "../../codegenv2/types.js", from: packageName + "/codegenv2" }, + GenMessage: { typeOnly: true, bootstrapWktFrom: "../../codegenv2/types.js", from: packageName + "/codegenv2" }, + GenService: { typeOnly: true, bootstrapWktFrom: "../../codegenv2/types.js", from: packageName + "/codegenv2" }, + }, +}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/types.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/types.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..286d368671bf87d8982f246461734072a2dedc33 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/types.d.ts @@ -0,0 +1,81 @@ +import type { Message } from "../types.js"; +import type { DescEnum, DescEnumValue, DescExtension, DescField, DescFile, DescMessage, DescMethod, DescService } from "../descriptors.js"; +import type { JsonValue } from "../json-value.js"; +/** + * Describes a protobuf source file. + * + * @private + */ +export type GenFile = DescFile; +/** + * Describes a message declaration in a protobuf source file. + * + * This type is identical to DescMessage, but carries additional type + * information. + * + * @private + */ +export type GenMessage = Omit & { + field: Record, DescField>; + typeName: RuntimeShape["$typeName"]; +} & brandv2; +/** + * Describes an enumeration in a protobuf source file. + * + * This type is identical to DescEnum, but carries additional type + * information. + * + * @private + */ +export type GenEnum = Omit & { + value: Record; +} & brandv2; +/** + * Describes an extension in a protobuf source file. + * + * This type is identical to DescExtension, but carries additional type + * information. + * + * @private + */ +export type GenExtension = DescExtension & brandv2; +/** + * Describes a service declaration in a protobuf source file. + * + * This type is identical to DescService, but carries additional type + * information. + * + * @private + */ +export type GenService = Omit & { + method: { + [K in keyof RuntimeShape]: RuntimeShape[K] & DescMethod; + }; +}; +/** + * @private + */ +export type GenServiceMethods = Record>; +declare class brandv2 { + protected v: "codegenv2"; + protected a: A | boolean; + protected b: B | boolean; +} +/** + * Union of the property names of all fields, including oneof members. + * For an anonymous message (no generated message shape), it's simply a string. + */ +type MessageFieldNames = Message extends T ? string : Exclude ? K : P]-?: true; +}, number | symbol>; +type Oneof = { + case: K | undefined; + value?: unknown; +}; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/types.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/types.js new file mode 100644 index 0000000000000000000000000000000000000000..b7cf882d181c235d2465c444be88e0041a43bbeb --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/codegenv2/types.js @@ -0,0 +1,21 @@ +// Copyright 2021-2025 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. +class brandv2 { + constructor() { + this.v = "codegenv2"; + this.a = false; + this.b = false; + } +} +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/create.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/create.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0f86a361522a94c12d01108b0de456179ad9bf0a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/create.d.ts @@ -0,0 +1,9 @@ +import { type DescMessage } from "./descriptors.js"; +import type { MessageInitShape, MessageShape } from "./types.js"; +/** + * Create a new message instance. + * + * The second argument is an optional initializer object, where all fields are + * optional. + */ +export declare function create(schema: Desc, init?: MessageInitShape): MessageShape; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/create.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/create.js new file mode 100644 index 0000000000000000000000000000000000000000..8f50ebd7e828bd68623cb4d3e9b707448b574ef9 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/create.js @@ -0,0 +1,256 @@ +// Copyright 2021-2025 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. +import { isMessage } from "./is-message.js"; +import { ScalarType, } from "./descriptors.js"; +import { scalarZeroValue } from "./reflect/scalar.js"; +import { isObject } from "./reflect/guard.js"; +import { unsafeGet, unsafeOneofCase, unsafeSet } from "./reflect/unsafe.js"; +import { isWrapperDesc } from "./wkt/wrappers.js"; +// bootstrap-inject google.protobuf.Edition.EDITION_PROTO3: const $name: Edition.$localName = $number; +const EDITION_PROTO3 = 999; +// bootstrap-inject google.protobuf.Edition.EDITION_PROTO2: const $name: Edition.$localName = $number; +const EDITION_PROTO2 = 998; +// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number; +const IMPLICIT = 2; +/** + * Create a new message instance. + * + * The second argument is an optional initializer object, where all fields are + * optional. + */ +export function create(schema, init) { + if (isMessage(init, schema)) { + return init; + } + const message = createZeroMessage(schema); + if (init !== undefined) { + initMessage(schema, message, init); + } + return message; +} +/** + * Sets field values from a MessageInitShape on a zero message. + */ +function initMessage(messageDesc, message, init) { + for (const member of messageDesc.members) { + let value = init[member.localName]; + if (value == null) { + // intentionally ignore undefined and null + continue; + } + let field; + if (member.kind == "oneof") { + const oneofField = unsafeOneofCase(init, member); + if (!oneofField) { + continue; + } + field = oneofField; + value = unsafeGet(init, oneofField); + } + else { + field = member; + } + switch (field.fieldKind) { + case "message": + value = toMessage(field, value); + break; + case "scalar": + value = initScalar(field, value); + break; + case "list": + value = initList(field, value); + break; + case "map": + value = initMap(field, value); + break; + } + unsafeSet(message, field, value); + } + return message; +} +function initScalar(field, value) { + if (field.scalar == ScalarType.BYTES) { + return toU8Arr(value); + } + return value; +} +function initMap(field, value) { + if (isObject(value)) { + if (field.scalar == ScalarType.BYTES) { + return convertObjectValues(value, toU8Arr); + } + if (field.mapKind == "message") { + return convertObjectValues(value, (val) => toMessage(field, val)); + } + } + return value; +} +function initList(field, value) { + if (Array.isArray(value)) { + if (field.scalar == ScalarType.BYTES) { + return value.map(toU8Arr); + } + if (field.listKind == "message") { + return value.map((item) => toMessage(field, item)); + } + } + return value; +} +function toMessage(field, value) { + if (field.fieldKind == "message" && + !field.oneof && + isWrapperDesc(field.message)) { + // Types from google/protobuf/wrappers.proto are unwrapped when used in + // a singular field that is not part of a oneof group. + return initScalar(field.message.fields[0], value); + } + if (isObject(value)) { + if (field.message.typeName == "google.protobuf.Struct" && + field.parent.typeName !== "google.protobuf.Value") { + // google.protobuf.Struct is represented with JsonObject when used in a + // field, except when used in google.protobuf.Value. + return value; + } + if (!isMessage(value, field.message)) { + return create(field.message, value); + } + } + return value; +} +// converts any ArrayLike to Uint8Array if necessary. +function toU8Arr(value) { + return Array.isArray(value) ? new Uint8Array(value) : value; +} +function convertObjectValues(obj, fn) { + const ret = {}; + for (const entry of Object.entries(obj)) { + ret[entry[0]] = fn(entry[1]); + } + return ret; +} +const tokenZeroMessageField = Symbol(); +const messagePrototypes = new WeakMap(); +/** + * Create a zero message. + */ +function createZeroMessage(desc) { + let msg; + if (!needsPrototypeChain(desc)) { + msg = { + $typeName: desc.typeName, + }; + for (const member of desc.members) { + if (member.kind == "oneof" || member.presence == IMPLICIT) { + msg[member.localName] = createZeroField(member); + } + } + } + else { + // Support default values and track presence via the prototype chain + const cached = messagePrototypes.get(desc); + let prototype; + let members; + if (cached) { + ({ prototype, members } = cached); + } + else { + prototype = {}; + members = new Set(); + for (const member of desc.members) { + if (member.kind == "oneof") { + // we can only put immutable values on the prototype, + // oneof ADTs are mutable + continue; + } + if (member.fieldKind != "scalar" && member.fieldKind != "enum") { + // only scalar and enum values are immutable, map, list, and message + // are not + continue; + } + if (member.presence == IMPLICIT) { + // implicit presence tracks field presence by zero values - e.g. 0, false, "", are unset, 1, true, "x" are set. + // message, map, list fields are mutable, and also have IMPLICIT presence. + continue; + } + members.add(member); + prototype[member.localName] = createZeroField(member); + } + messagePrototypes.set(desc, { prototype, members }); + } + msg = Object.create(prototype); + msg.$typeName = desc.typeName; + for (const member of desc.members) { + if (members.has(member)) { + continue; + } + if (member.kind == "field") { + if (member.fieldKind == "message") { + continue; + } + if (member.fieldKind == "scalar" || member.fieldKind == "enum") { + if (member.presence != IMPLICIT) { + continue; + } + } + } + msg[member.localName] = createZeroField(member); + } + } + return msg; +} +/** + * Do we need the prototype chain to track field presence? + */ +function needsPrototypeChain(desc) { + switch (desc.file.edition) { + case EDITION_PROTO3: + // proto3 always uses implicit presence, we never need the prototype chain. + return false; + case EDITION_PROTO2: + // proto2 never uses implicit presence, we always need the prototype chain. + return true; + default: + // If a message uses scalar or enum fields with explicit presence, we need + // the prototype chain to track presence. This rule does not apply to fields + // in a oneof group - they use a different mechanism to track presence. + return desc.fields.some((f) => f.presence != IMPLICIT && f.fieldKind != "message" && !f.oneof); + } +} +/** + * Returns a zero value for oneof groups, and for every field kind except + * messages. Scalar and enum fields can have default values. + */ +function createZeroField(field) { + if (field.kind == "oneof") { + return { case: undefined }; + } + if (field.fieldKind == "list") { + return []; + } + if (field.fieldKind == "map") { + return {}; // Object.create(null) would be desirable here, but is unsupported by react https://react.dev/reference/react/use-server#serializable-parameters-and-return-values + } + if (field.fieldKind == "message") { + return tokenZeroMessageField; + } + const defaultValue = field.getDefaultValue(); + if (defaultValue !== undefined) { + return field.fieldKind == "scalar" && field.longAsString + ? defaultValue.toString() + : defaultValue; + } + return field.fieldKind == "scalar" + ? scalarZeroValue(field.scalar, field.longAsString) + : field.enum.values[0].number; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/descriptors.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/descriptors.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..98e0c412f98853d1e0cf44c0c45d62c2f2e1c2b2 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/descriptors.d.ts @@ -0,0 +1,627 @@ +import type { DescriptorProto, Edition, EnumDescriptorProto, EnumValueDescriptorProto, FeatureSet_FieldPresence, FieldDescriptorProto, FileDescriptorProto, MethodDescriptorProto, MethodOptions_IdempotencyLevel, OneofDescriptorProto, ServiceDescriptorProto } from "./wkt/gen/google/protobuf/descriptor_pb.js"; +import type { ScalarValue } from "./reflect/scalar.js"; +export type SupportedEdition = Extract; +type SupportedFieldPresence = Extract; +/** + * Scalar value types. This is a subset of field types declared by protobuf + * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE + * are omitted, but the numerical values are identical. + */ +export declare enum ScalarType { + DOUBLE = 1, + FLOAT = 2, + INT64 = 3, + UINT64 = 4, + INT32 = 5, + FIXED64 = 6, + FIXED32 = 7, + BOOL = 8, + STRING = 9, + BYTES = 12, + UINT32 = 13, + SFIXED32 = 15, + SFIXED64 = 16, + SINT32 = 17,// Uses ZigZag encoding. + SINT64 = 18 +} +/** + * A union of all descriptors, discriminated by a `kind` property. + */ +export type AnyDesc = DescFile | DescEnum | DescEnumValue | DescMessage | DescField | DescExtension | DescOneof | DescService | DescMethod; +/** + * Describes a protobuf source file. + */ +export interface DescFile { + readonly kind: "file"; + /** + * The edition of the protobuf file. Will be EDITION_PROTO2 for syntax="proto2", + * EDITION_PROTO3 for syntax="proto3"; + */ + readonly edition: SupportedEdition; + /** + * The name of the file, excluding the .proto suffix. + * For a protobuf file `foo/bar.proto`, this is `foo/bar`. + */ + readonly name: string; + /** + * Files imported by this file. + */ + readonly dependencies: DescFile[]; + /** + * Top-level enumerations declared in this file. + * Note that more enumerations might be declared within message declarations. + */ + readonly enums: DescEnum[]; + /** + * Top-level messages declared in this file. + * Note that more messages might be declared within message declarations. + */ + readonly messages: DescMessage[]; + /** + * Top-level extensions declared in this file. + * Note that more extensions might be declared within message declarations. + */ + readonly extensions: DescExtension[]; + /** + * Services declared in this file. + */ + readonly services: DescService[]; + /** + * Marked as deprecated in the protobuf source. + */ + readonly deprecated: boolean; + /** + * The compiler-generated descriptor. + */ + readonly proto: FileDescriptorProto; + toString(): string; +} +/** + * Describes an enumeration in a protobuf source file. + */ +export interface DescEnum { + readonly kind: "enum"; + /** + * The fully qualified name of the enumeration. (We omit the leading dot.) + */ + readonly typeName: string; + /** + * The name of the enumeration, as declared in the protobuf source. + */ + readonly name: string; + /** + * The file this enumeration was declared in. + */ + readonly file: DescFile; + /** + * The parent message, if this enumeration was declared inside a message declaration. + */ + readonly parent: DescMessage | undefined; + /** + * Enumerations can be open or closed. + * See https://protobuf.dev/programming-guides/enum/ + */ + readonly open: boolean; + /** + * Values declared for this enumeration. + */ + readonly values: DescEnumValue[]; + /** + * All values of this enum by their number. + */ + readonly value: Record; + /** + * A prefix shared by all enum values. + * For example, `my_enum_` for `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}` + */ + readonly sharedPrefix?: string; + /** + * Marked as deprecated in the protobuf source. + */ + readonly deprecated: boolean; + /** + * The compiler-generated descriptor. + */ + readonly proto: EnumDescriptorProto; + toString(): string; +} +/** + * Describes an individual value of an enumeration in a protobuf source file. + */ +export interface DescEnumValue { + readonly kind: "enum_value"; + /** + * The name of the enumeration value, as specified in the protobuf source. + */ + readonly name: string; + /** + * A safe and idiomatic name for the value in a TypeScript enum. + */ + readonly localName: string; + /** + * The enumeration this value belongs to. + */ + readonly parent: DescEnum; + /** + * The numeric enumeration value, as specified in the protobuf source. + */ + readonly number: number; + /** + * Marked as deprecated in the protobuf source. + */ + readonly deprecated: boolean; + /** + * The compiler-generated descriptor. + */ + readonly proto: EnumValueDescriptorProto; + toString(): string; +} +/** + * Describes a message declaration in a protobuf source file. + */ +export interface DescMessage { + readonly kind: "message"; + /** + * The fully qualified name of the message. (We omit the leading dot.) + */ + readonly typeName: string; + /** + * The name of the message, as specified in the protobuf source. + */ + readonly name: string; + /** + * The file this message was declared in. + */ + readonly file: DescFile; + /** + * The parent message, if this message was declared inside a message declaration. + */ + readonly parent: DescMessage | undefined; + /** + * Fields declared for this message, including fields declared in a oneof + * group. + */ + readonly fields: DescField[]; + /** + * All fields of this message by their "localName". + */ + readonly field: Record; + /** + * Oneof groups declared for this message. + * This does not include synthetic oneofs for proto3 optionals. + */ + readonly oneofs: DescOneof[]; + /** + * Fields and oneof groups for this message, ordered by their appearance in the + * protobuf source. + */ + readonly members: (DescField | DescOneof)[]; + /** + * Enumerations declared within the message, if any. + */ + readonly nestedEnums: DescEnum[]; + /** + * Messages declared within the message, if any. + * This does not include synthetic messages like map entries. + */ + readonly nestedMessages: DescMessage[]; + /** + * Extensions declared within the message, if any. + */ + readonly nestedExtensions: DescExtension[]; + /** + * Marked as deprecated in the protobuf source. + */ + readonly deprecated: boolean; + /** + * The compiler-generated descriptor. + */ + readonly proto: DescriptorProto; + toString(): string; +} +/** + * Describes a field declaration in a protobuf source file. + */ +export type DescField = (descFieldScalar & descFieldCommon) | (descFieldList & descFieldCommon) | (descFieldMessage & descFieldCommon) | (descFieldEnum & descFieldCommon) | (descFieldMap & descFieldCommon); +type descFieldCommon = descFieldAndExtensionShared & { + readonly kind: "field"; + /** + * The message this field is declared on. + */ + readonly parent: DescMessage; + /** + * A safe and idiomatic name for the field as a property in ECMAScript. + */ + readonly localName: string; +}; +/** + * Describes an extension in a protobuf source file. + */ +export type DescExtension = (Omit & descExtensionCommon) | (Omit & descExtensionCommon) | (Omit & descExtensionCommon) | (descFieldList & descExtensionCommon); +type descExtensionCommon = descFieldAndExtensionShared & { + readonly kind: "extension"; + /** + * The fully qualified name of the extension. + */ + readonly typeName: string; + /** + * The file this extension was declared in. + */ + readonly file: DescFile; + /** + * The parent message, if this extension was declared inside a message declaration. + */ + readonly parent: DescMessage | undefined; + /** + * The message that this extension extends. + */ + readonly extendee: DescMessage; + /** + * The `oneof` group this field belongs to, if any. + */ + readonly oneof: undefined; +}; +interface descFieldAndExtensionShared { + /** + * The field name, as specified in the protobuf source + */ + readonly name: string; + /** + * The field number, as specified in the protobuf source. + */ + readonly number: number; + /** + * The field name in JSON. + */ + readonly jsonName: string; + /** + * Marked as deprecated in the protobuf source. + */ + readonly deprecated: boolean; + /** + * Presence of the field. + * See https://protobuf.dev/programming-guides/field_presence/ + */ + readonly presence: SupportedFieldPresence; + /** + * The compiler-generated descriptor. + */ + readonly proto: FieldDescriptorProto; + /** + * Get the edition features for this protobuf element. + */ + toString(): string; +} +type descFieldSingularCommon = { + /** + * The `oneof` group this field belongs to, if any. + * + * This does not include synthetic oneofs for proto3 optionals. + */ + readonly oneof: DescOneof | undefined; +}; +type descFieldScalar = T extends T ? { + readonly fieldKind: "scalar"; + /** + * Scalar type, if it is a scalar field. + */ + readonly scalar: T; + /** + * By default, 64-bit integral types (int64, uint64, sint64, fixed64, + * sfixed64) are represented with BigInt. + * + * If the field option `jstype = JS_STRING` is set, this property + * is true, and 64-bit integral types are represented with String. + */ + readonly longAsString: boolean; + /** + * The message type, if it is a message field. + */ + readonly message: undefined; + /** + * The enum type, if it is an enum field. + */ + readonly enum: undefined; + /** + * Return the default value specified in the protobuf source. + */ + getDefaultValue(): ScalarValue | undefined; +} & descFieldSingularCommon : never; +type descFieldMessage = { + readonly fieldKind: "message"; + /** + * Scalar type, if it is a scalar field. + */ + readonly scalar: undefined; + /** + * The message type, if it is a message field. + */ + readonly message: DescMessage; + /** + * Encode the message delimited (a.k.a. proto2 group encoding), or + * length-prefixed? + */ + readonly delimitedEncoding: boolean; + /** + * The enum type, if it is an enum field. + */ + readonly enum: undefined; + /** + * Return the default value specified in the protobuf source. + */ + getDefaultValue(): undefined; +} & descFieldSingularCommon; +type descFieldEnum = { + readonly fieldKind: "enum"; + /** + * Scalar type, if it is a scalar field. + */ + readonly scalar: undefined; + /** + * The message type, if it is a message field. + */ + readonly message: undefined; + /** + * The enum type, if it is an enum field. + */ + readonly enum: DescEnum; + /** + * Return the default value specified in the protobuf source. + */ + getDefaultValue(): number | undefined; +} & descFieldSingularCommon; +type descFieldList = (descFieldListScalar & descFieldListCommon) | (descFieldListEnum & descFieldListCommon) | (descFieldListMessage & descFieldListCommon); +type descFieldListCommon = { + readonly fieldKind: "list"; + /** + * Pack this repeated field? Only valid for repeated enum fields, and + * for repeated scalar fields except BYTES and STRING. + */ + readonly packed: boolean; + /** + * The `oneof` group this field belongs to, if any. + */ + readonly oneof: undefined; +}; +type descFieldListScalar = T extends T ? { + readonly listKind: "scalar"; + /** + * The enum list element type. + */ + readonly enum: undefined; + /** + * The message list element type. + */ + readonly message: undefined; + /** + * Scalar list element type. + */ + readonly scalar: T; + /** + * By default, 64-bit integral types (int64, uint64, sint64, fixed64, + * sfixed64) are represented with BigInt. + * + * If the field option `jstype = JS_STRING` is set, this property + * is true, and 64-bit integral types are represented with String. + */ + readonly longAsString: boolean; +} : never; +type descFieldListEnum = { + readonly listKind: "enum"; + /** + * The enum list element type. + */ + readonly enum: DescEnum; + /** + * The message list element type. + */ + readonly message: undefined; + /** + * Scalar list element type. + */ + readonly scalar: undefined; +}; +type descFieldListMessage = { + readonly listKind: "message"; + /** + * The enum list element type. + */ + readonly enum: undefined; + /** + * The message list element type. + */ + readonly message: DescMessage; + /** + * Scalar list element type. + */ + readonly scalar: undefined; + /** + * Encode the message delimited (a.k.a. proto2 group encoding), or + * length-prefixed? + */ + readonly delimitedEncoding: boolean; +}; +type descFieldMap = (descFieldMapScalar & descFieldMapCommon) | (descFieldMapEnum & descFieldMapCommon) | (descFieldMapMessage & descFieldMapCommon); +type descFieldMapCommon = T extends Exclude ? { + readonly fieldKind: "map"; + /** + * The scalar map key type. + */ + readonly mapKey: T; + /** + * The `oneof` group this field belongs to, if any. + */ + readonly oneof: undefined; + /** + * Encode the map entry message delimited (a.k.a. proto2 group encoding), + * or length-prefixed? As of Edition 2023, this is always false for map fields, + * and also applies to map values, if they are messages. + */ + readonly delimitedEncoding: false; +} : never; +type descFieldMapScalar = T extends T ? { + readonly mapKind: "scalar"; + /** + * The enum map value type. + */ + readonly enum: undefined; + /** + * The message map value type. + */ + readonly message: undefined; + /** + * Scalar map value type. + */ + readonly scalar: T; +} : never; +type descFieldMapEnum = { + readonly mapKind: "enum"; + /** + * The enum map value type. + */ + readonly enum: DescEnum; + /** + * The message map value type. + */ + readonly message: undefined; + /** + * Scalar map value type. + */ + readonly scalar: undefined; +}; +type descFieldMapMessage = { + readonly mapKind: "message"; + /** + * The enum map value type. + */ + readonly enum: undefined; + /** + * The message map value type. + */ + readonly message: DescMessage; + /** + * Scalar map value type. + */ + readonly scalar: undefined; +}; +/** + * Describes a oneof group in a protobuf source file. + */ +export interface DescOneof { + readonly kind: "oneof"; + /** + * The name of the oneof group, as specified in the protobuf source. + */ + readonly name: string; + /** + * A safe and idiomatic name for the oneof group as a property in ECMAScript. + */ + readonly localName: string; + /** + * The message this oneof group was declared in. + */ + readonly parent: DescMessage; + /** + * The fields declared in this oneof group. + */ + readonly fields: DescField[]; + /** + * Marked as deprecated in the protobuf source. + * Note that oneof groups cannot be marked as deprecated, this property + * only exists for consistency and will always be false. + */ + readonly deprecated: boolean; + /** + * The compiler-generated descriptor. + */ + readonly proto: OneofDescriptorProto; + toString(): string; +} +/** + * Describes a service declaration in a protobuf source file. + */ +export interface DescService { + readonly kind: "service"; + /** + * The fully qualified name of the service. (We omit the leading dot.) + */ + readonly typeName: string; + /** + * The name of the service, as specified in the protobuf source. + */ + readonly name: string; + /** + * The file this service was declared in. + */ + readonly file: DescFile; + /** + * The RPCs this service declares. + */ + readonly methods: DescMethod[]; + /** + * All methods of this service by their "localName". + */ + readonly method: Record; + /** + * Marked as deprecated in the protobuf source. + */ + readonly deprecated: boolean; + /** + * The compiler-generated descriptor. + */ + readonly proto: ServiceDescriptorProto; + toString(): string; +} +/** + * Describes an RPC declaration in a protobuf source file. + */ +export interface DescMethod { + readonly kind: "rpc"; + /** + * The name of the RPC, as specified in the protobuf source. + */ + readonly name: string; + /** + * A safe and idiomatic name for the RPC as a method in ECMAScript. + */ + readonly localName: string; + /** + * The parent service. + */ + readonly parent: DescService; + /** + * One of the four available method types. + */ + readonly methodKind: "unary" | "server_streaming" | "client_streaming" | "bidi_streaming"; + /** + * The message type for requests. + */ + readonly input: DescMessage; + /** + * The message type for responses. + */ + readonly output: DescMessage; + /** + * The idempotency level declared in the protobuf source, if any. + */ + readonly idempotency: MethodOptions_IdempotencyLevel; + /** + * Marked as deprecated in the protobuf source. + */ + readonly deprecated: boolean; + /** + * The compiler-generated descriptor. + */ + readonly proto: MethodDescriptorProto; + toString(): string; +} +/** + * Comments on an element in a protobuf source file. + */ +export interface DescComments { + readonly leadingDetached: readonly string[]; + readonly leading?: string; + readonly trailing?: string; + readonly sourcePath: readonly number[]; +} +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/descriptors.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/descriptors.js new file mode 100644 index 0000000000000000000000000000000000000000..bb598e8073d73c0635f3a433e0c2aa669b914522 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/descriptors.js @@ -0,0 +1,50 @@ +// Copyright 2021-2025 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. +/** + * Scalar value types. This is a subset of field types declared by protobuf + * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE + * are omitted, but the numerical values are identical. + */ +export var ScalarType; +(function (ScalarType) { + // 0 is reserved for errors. + // Order is weird for historical reasons. + ScalarType[ScalarType["DOUBLE"] = 1] = "DOUBLE"; + ScalarType[ScalarType["FLOAT"] = 2] = "FLOAT"; + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + // negative values are likely. + ScalarType[ScalarType["INT64"] = 3] = "INT64"; + ScalarType[ScalarType["UINT64"] = 4] = "UINT64"; + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + // negative values are likely. + ScalarType[ScalarType["INT32"] = 5] = "INT32"; + ScalarType[ScalarType["FIXED64"] = 6] = "FIXED64"; + ScalarType[ScalarType["FIXED32"] = 7] = "FIXED32"; + ScalarType[ScalarType["BOOL"] = 8] = "BOOL"; + ScalarType[ScalarType["STRING"] = 9] = "STRING"; + // Tag-delimited aggregate. + // Group type is deprecated and not supported in proto3. However, Proto3 + // implementations should still be able to parse the group wire format and + // treat group fields as unknown fields. + // TYPE_GROUP = 10, + // TYPE_MESSAGE = 11, // Length-delimited aggregate. + // New in version 2. + ScalarType[ScalarType["BYTES"] = 12] = "BYTES"; + ScalarType[ScalarType["UINT32"] = 13] = "UINT32"; + // TYPE_ENUM = 14, + ScalarType[ScalarType["SFIXED32"] = 15] = "SFIXED32"; + ScalarType[ScalarType["SFIXED64"] = 16] = "SFIXED64"; + ScalarType[ScalarType["SINT32"] = 17] = "SINT32"; + ScalarType[ScalarType["SINT64"] = 18] = "SINT64"; +})(ScalarType || (ScalarType = {})); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/equals.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/equals.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..914048f1113e355bf52f78cafad18caf89bc0533 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/equals.d.ts @@ -0,0 +1,41 @@ +import type { MessageShape } from "./types.js"; +import { type DescMessage } from "./descriptors.js"; +import type { Registry } from "./registry.js"; +interface EqualsOptions { + /** + * A registry to look up extensions, and messages packed in Any. + * + * @private Experimental API, does not follow semantic versioning. + */ + registry: Registry; + /** + * Unpack google.protobuf.Any before comparing. + * If a type is not in the registry, comparison falls back to comparing the + * fields of Any. + * + * @private Experimental API, does not follow semantic versioning. + */ + unpackAny?: boolean; + /** + * Consider extensions when comparing. + * + * @private Experimental API, does not follow semantic versioning. + */ + extensions?: boolean; + /** + * Consider unknown fields when comparing. + * The registry is used to distinguish between extensions, and unknown fields + * caused by schema changes. + * + * @private Experimental API, does not follow semantic versioning. + */ + unknown?: boolean; +} +/** + * Compare two messages of the same type. + * + * Note that this function disregards extensions and unknown fields, and that + * NaN is not equal NaN, following the IEEE standard. + */ +export declare function equals(schema: Desc, a: MessageShape, b: MessageShape, options?: EqualsOptions): boolean; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/equals.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/equals.js new file mode 100644 index 0000000000000000000000000000000000000000..23b178cce12488e71aa5dbcbc53ed9ea4b5d9d1e --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/equals.js @@ -0,0 +1,201 @@ +// Copyright 2021-2025 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. +import { scalarEquals } from "./reflect/scalar.js"; +import { reflect } from "./reflect/reflect.js"; +import { ScalarType, } from "./descriptors.js"; +import { anyUnpack } from "./wkt/index.js"; +import { createExtensionContainer, getExtension } from "./extensions.js"; +/** + * Compare two messages of the same type. + * + * Note that this function disregards extensions and unknown fields, and that + * NaN is not equal NaN, following the IEEE standard. + */ +export function equals(schema, a, b, options) { + if (a.$typeName != schema.typeName || b.$typeName != schema.typeName) { + return false; + } + if (a === b) { + return true; + } + return reflectEquals(reflect(schema, a), reflect(schema, b), options); +} +function reflectEquals(a, b, opts) { + if (a.desc.typeName === "google.protobuf.Any" && (opts === null || opts === void 0 ? void 0 : opts.unpackAny) == true) { + return anyUnpackedEquals(a.message, b.message, opts); + } + for (const f of a.fields) { + if (!fieldEquals(f, a, b, opts)) { + return false; + } + } + if ((opts === null || opts === void 0 ? void 0 : opts.unknown) == true && !unknownEquals(a, b, opts.registry)) { + return false; + } + if ((opts === null || opts === void 0 ? void 0 : opts.extensions) == true && !extensionsEquals(a, b, opts)) { + return false; + } + return true; +} +// TODO(tstamm) add an option to consider NaN equal to NaN? +function fieldEquals(f, a, b, opts) { + if (!a.isSet(f) && !b.isSet(f)) { + return true; + } + if (!a.isSet(f) || !b.isSet(f)) { + return false; + } + switch (f.fieldKind) { + case "scalar": + return scalarEquals(f.scalar, a.get(f), b.get(f)); + case "enum": + return a.get(f) === b.get(f); + case "message": + return reflectEquals(a.get(f), b.get(f), opts); + case "map": { + // TODO(tstamm) can't we compare sizes first? + const mapA = a.get(f); + const mapB = b.get(f); + const keys = []; + for (const k of mapA.keys()) { + if (!mapB.has(k)) { + return false; + } + keys.push(k); + } + for (const k of mapB.keys()) { + if (!mapA.has(k)) { + return false; + } + } + for (const key of keys) { + const va = mapA.get(key); + const vb = mapB.get(key); + if (va === vb) { + continue; + } + switch (f.mapKind) { + case "enum": + return false; + case "message": + if (!reflectEquals(va, vb, opts)) { + return false; + } + break; + case "scalar": + if (!scalarEquals(f.scalar, va, vb)) { + return false; + } + break; + } + } + break; + } + case "list": { + const listA = a.get(f); + const listB = b.get(f); + if (listA.size != listB.size) { + return false; + } + for (let i = 0; i < listA.size; i++) { + const va = listA.get(i); + const vb = listB.get(i); + if (va === vb) { + continue; + } + switch (f.listKind) { + case "enum": + return false; + case "message": + if (!reflectEquals(va, vb, opts)) { + return false; + } + break; + case "scalar": + if (!scalarEquals(f.scalar, va, vb)) { + return false; + } + break; + } + } + break; + } + } + return true; +} +function anyUnpackedEquals(a, b, opts) { + if (a.typeUrl !== b.typeUrl) { + return false; + } + const unpackedA = anyUnpack(a, opts.registry); + const unpackedB = anyUnpack(b, opts.registry); + if (unpackedA && unpackedB) { + const schema = opts.registry.getMessage(unpackedA.$typeName); + if (schema) { + return equals(schema, unpackedA, unpackedB, opts); + } + } + return scalarEquals(ScalarType.BYTES, a.value, b.value); +} +function unknownEquals(a, b, registry) { + function getTrulyUnknown(msg, registry) { + var _a; + const u = (_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : []; + return registry + ? u.filter((uf) => !registry.getExtensionFor(msg.desc, uf.no)) + : u; + } + const unknownA = getTrulyUnknown(a, registry); + const unknownB = getTrulyUnknown(b, registry); + if (unknownA.length != unknownB.length) { + return false; + } + for (let i = 0; i < unknownA.length; i++) { + const a = unknownA[i]; + const b = unknownB[i]; + if (a.no != b.no) { + return false; + } + if (a.wireType != b.wireType) { + return false; + } + if (!scalarEquals(ScalarType.BYTES, a.data, b.data)) { + return false; + } + } + return true; +} +function extensionsEquals(a, b, opts) { + function getSetExtensions(msg, registry) { + var _a; + return ((_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : []) + .map((uf) => registry.getExtensionFor(msg.desc, uf.no)) + .filter((e) => e != undefined) + .filter((e, index, arr) => arr.indexOf(e) === index); + } + const extensionsA = getSetExtensions(a, opts.registry); + const extensionsB = getSetExtensions(b, opts.registry); + if (extensionsA.length != extensionsB.length || + extensionsA.some((e) => !extensionsB.includes(e))) { + return false; + } + for (const extension of extensionsA) { + const [containerA, field] = createExtensionContainer(extension, getExtension(a.message, extension)); + const [containerB] = createExtensionContainer(extension, getExtension(b.message, extension)); + if (!fieldEquals(field, containerA, containerB, opts)) { + return false; + } + } + return true; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/extensions.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/extensions.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..83364472906fc70b9d9d4669fe98776e9e2fce19 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/extensions.d.ts @@ -0,0 +1,59 @@ +import type { AnyDesc, DescEnum, DescEnumValue, DescExtension, DescField, DescFile, DescMessage, DescMethod, DescOneof, DescService } from "./descriptors.js"; +import type { ReflectMessage } from "./reflect/reflect-types.js"; +import type { Extendee, ExtensionValueShape } from "./types.js"; +import type { EnumOptions, EnumValueOptions, FieldOptions, FileOptions, MessageOptions, MethodOptions, OneofOptions, ServiceOptions } from "./wkt/gen/google/protobuf/descriptor_pb.js"; +/** + * Retrieve an extension value from a message. + * + * The function never returns undefined. Use hasExtension() to check whether an + * extension is set. If the extension is not set, this function returns the + * default value (if one was specified in the protobuf source), or the zero value + * (for example `0` for numeric types, `[]` for repeated extension fields, and + * an empty message instance for message fields). + * + * Extensions are stored as unknown fields on a message. To mutate an extension + * value, make sure to store the new value with setExtension() after mutating. + * + * If the extension does not extend the given message, an error is raised. + */ +export declare function getExtension(message: Extendee, extension: Desc): ExtensionValueShape; +/** + * Set an extension value on a message. If the message already has a value for + * this extension, the value is replaced. + * + * If the extension does not extend the given message, an error is raised. + */ +export declare function setExtension(message: Extendee, extension: Desc, value: ExtensionValueShape): void; +/** + * Remove an extension value from a message. + * + * If the extension does not extend the given message, an error is raised. + */ +export declare function clearExtension(message: Extendee, extension: Desc): void; +/** + * Check whether an extension is set on a message. + */ +export declare function hasExtension(message: Extendee, extension: Desc): boolean; +/** + * Check whether an option is set on a descriptor. + * + * Options are extensions to the `google.protobuf.*Options` messages defined in + * google/protobuf/descriptor.proto. This function gets the option message from + * the descriptor, and calls hasExtension(). + */ +export declare function hasOption>(element: Desc, option: Ext): boolean; +/** + * Retrieve an option value from a descriptor. + * + * Options are extensions to the `google.protobuf.*Options` messages defined in + * google/protobuf/descriptor.proto. This function gets the option message from + * the descriptor, and calls getExtension(). Same as getExtension(), this + * function never returns undefined. + */ +export declare function getOption>(element: Desc, option: Ext): ExtensionValueShape; +type DescForOptionExtension = Extendee extends FileOptions ? DescFile : Extendee extends EnumOptions ? DescEnum : Extendee extends EnumValueOptions ? DescEnumValue : Extendee extends MessageOptions ? DescMessage : Extendee extends MessageOptions ? DescEnum : Extendee extends FieldOptions ? DescField | DescExtension : Extendee extends OneofOptions ? DescOneof : Extendee extends ServiceOptions ? DescService : Extendee extends EnumOptions ? DescEnum : Extendee extends MethodOptions ? DescMethod : AnyDesc; +/** + * @private + */ +export declare function createExtensionContainer(extension: Desc, value?: ExtensionValueShape): [ReflectMessage, DescField, () => ExtensionValueShape]; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/extensions.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/extensions.js new file mode 100644 index 0000000000000000000000000000000000000000..24191f92979dacb56f2550e11de430110f7bfa2f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/extensions.js @@ -0,0 +1,160 @@ +// Copyright 2021-2025 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. +import { create } from "./create.js"; +import { readField } from "./from-binary.js"; +import { reflect } from "./reflect/reflect.js"; +import { scalarZeroValue } from "./reflect/scalar.js"; +import { writeField } from "./to-binary.js"; +import { BinaryReader, BinaryWriter } from "./wire/binary-encoding.js"; +import { isWrapperDesc } from "./wkt/wrappers.js"; +/** + * Retrieve an extension value from a message. + * + * The function never returns undefined. Use hasExtension() to check whether an + * extension is set. If the extension is not set, this function returns the + * default value (if one was specified in the protobuf source), or the zero value + * (for example `0` for numeric types, `[]` for repeated extension fields, and + * an empty message instance for message fields). + * + * Extensions are stored as unknown fields on a message. To mutate an extension + * value, make sure to store the new value with setExtension() after mutating. + * + * If the extension does not extend the given message, an error is raised. + */ +export function getExtension(message, extension) { + assertExtendee(extension, message); + const ufs = filterUnknownFields(message.$unknown, extension); + const [container, field, get] = createExtensionContainer(extension); + for (const uf of ufs) { + readField(container, new BinaryReader(uf.data), field, uf.wireType, { + readUnknownFields: true, + }); + } + return get(); +} +/** + * Set an extension value on a message. If the message already has a value for + * this extension, the value is replaced. + * + * If the extension does not extend the given message, an error is raised. + */ +export function setExtension(message, extension, value) { + var _a; + assertExtendee(extension, message); + const ufs = ((_a = message.$unknown) !== null && _a !== void 0 ? _a : []).filter((uf) => uf.no !== extension.number); + const [container, field] = createExtensionContainer(extension, value); + const writer = new BinaryWriter(); + writeField(writer, { writeUnknownFields: true }, container, field); + const reader = new BinaryReader(writer.finish()); + while (reader.pos < reader.len) { + const [no, wireType] = reader.tag(); + const data = reader.skip(wireType, no); + ufs.push({ no, wireType, data }); + } + message.$unknown = ufs; +} +/** + * Remove an extension value from a message. + * + * If the extension does not extend the given message, an error is raised. + */ +export function clearExtension(message, extension) { + assertExtendee(extension, message); + if (message.$unknown === undefined) { + return; + } + message.$unknown = message.$unknown.filter((uf) => uf.no !== extension.number); +} +/** + * Check whether an extension is set on a message. + */ +export function hasExtension(message, extension) { + var _a; + return (extension.extendee.typeName === message.$typeName && + !!((_a = message.$unknown) === null || _a === void 0 ? void 0 : _a.find((uf) => uf.no === extension.number))); +} +/** + * Check whether an option is set on a descriptor. + * + * Options are extensions to the `google.protobuf.*Options` messages defined in + * google/protobuf/descriptor.proto. This function gets the option message from + * the descriptor, and calls hasExtension(). + */ +export function hasOption(element, option) { + const message = element.proto.options; + if (!message) { + return false; + } + return hasExtension(message, option); +} +/** + * Retrieve an option value from a descriptor. + * + * Options are extensions to the `google.protobuf.*Options` messages defined in + * google/protobuf/descriptor.proto. This function gets the option message from + * the descriptor, and calls getExtension(). Same as getExtension(), this + * function never returns undefined. + */ +export function getOption(element, option) { + const message = element.proto.options; + if (!message) { + const [, , get] = createExtensionContainer(option); + return get(); + } + return getExtension(message, option); +} +function filterUnknownFields(unknownFields, extension) { + if (unknownFields === undefined) + return []; + if (extension.fieldKind === "enum" || extension.fieldKind === "scalar") { + // singular scalar fields do not merge, we pick the last + for (let i = unknownFields.length - 1; i >= 0; --i) { + if (unknownFields[i].no == extension.number) { + return [unknownFields[i]]; + } + } + return []; + } + return unknownFields.filter((uf) => uf.no === extension.number); +} +/** + * @private + */ +export function createExtensionContainer(extension, value) { + const localName = extension.typeName; + const field = Object.assign(Object.assign({}, extension), { kind: "field", parent: extension.extendee, localName }); + const desc = Object.assign(Object.assign({}, extension.extendee), { fields: [field], members: [field], oneofs: [] }); + const container = create(desc, value !== undefined ? { [localName]: value } : undefined); + return [ + reflect(desc, container), + field, + () => { + const value = container[localName]; + if (value === undefined) { + // biome-ignore lint/style/noNonNullAssertion: Only message fields are undefined, rest will have a zero value. + const desc = extension.message; + if (isWrapperDesc(desc)) { + return scalarZeroValue(desc.fields[0].scalar, desc.fields[0].longAsString); + } + return create(desc); + } + return value; + }, + ]; +} +function assertExtendee(extension, message) { + if (extension.extendee.typeName != message.$typeName) { + throw new Error(`extension ${extension.typeName} can only be applied to message ${extension.extendee.typeName}`); + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/fields.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/fields.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a44a0c87280b251a4c7fd1b83d0e170c9a588d10 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/fields.d.ts @@ -0,0 +1,23 @@ +import type { MessageShape } from "./types.js"; +import type { DescField, DescMessage } from "./descriptors.js"; +/** + * Returns true if the field is set. + * + * - Scalar and enum fields with implicit presence (proto3): + * Set if not a zero value. + * + * - Scalar and enum fields with explicit presence (proto2, oneof): + * Set if a value was set when creating or parsing the message, or when a + * value was assigned to the field's property. + * + * - Message fields: + * Set if the property is not undefined. + * + * - List and map fields: + * Set if not empty. + */ +export declare function isFieldSet(message: MessageShape, field: DescField): boolean; +/** + * Resets the field, so that isFieldSet() will return false. + */ +export declare function clearField(message: MessageShape, field: DescField): void; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/fields.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/fields.js new file mode 100644 index 0000000000000000000000000000000000000000..788290be55ae092a6900474571281460ede2461b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/fields.js @@ -0,0 +1,41 @@ +// Copyright 2021-2025 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. +import { unsafeClear, unsafeIsSet } from "./reflect/unsafe.js"; +/** + * Returns true if the field is set. + * + * - Scalar and enum fields with implicit presence (proto3): + * Set if not a zero value. + * + * - Scalar and enum fields with explicit presence (proto2, oneof): + * Set if a value was set when creating or parsing the message, or when a + * value was assigned to the field's property. + * + * - Message fields: + * Set if the property is not undefined. + * + * - List and map fields: + * Set if not empty. + */ +export function isFieldSet(message, field) { + return (field.parent.typeName == message.$typeName && unsafeIsSet(message, field)); +} +/** + * Resets the field, so that isFieldSet() will return false. + */ +export function clearField(message, field) { + if (field.parent.typeName == message.$typeName) { + unsafeClear(message, field); + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/from-binary.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/from-binary.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b04a9d39ed2ca08cb6329fb5ffed916868f8f5db --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/from-binary.d.ts @@ -0,0 +1,34 @@ +import { type DescField, type DescMessage } from "./descriptors.js"; +import type { MessageShape } from "./types.js"; +import type { ReflectMessage } from "./reflect/index.js"; +import { BinaryReader, WireType } from "./wire/binary-encoding.js"; +/** + * Options for parsing binary data. + */ +export interface BinaryReadOptions { + /** + * Retain unknown fields during parsing? The default behavior is to retain + * unknown fields and include them in the serialized output. + * + * For more details see https://developers.google.com/protocol-buffers/docs/proto3#unknowns + */ + readUnknownFields: boolean; +} +/** + * Parse serialized binary data. + */ +export declare function fromBinary(schema: Desc, bytes: Uint8Array, options?: Partial): MessageShape; +/** + * Parse from binary data, merging fields. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ +export declare function mergeFromBinary(schema: Desc, target: MessageShape, bytes: Uint8Array, options?: Partial): MessageShape; +/** + * @private + */ +export declare function readField(message: ReflectMessage, reader: BinaryReader, field: DescField, wireType: WireType, options: BinaryReadOptions): void; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/from-binary.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/from-binary.js new file mode 100644 index 0000000000000000000000000000000000000000..d90d052528ad873eeaf2735b92c4302d2a4765cf --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/from-binary.js @@ -0,0 +1,236 @@ +// Copyright 2021-2025 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. +import { ScalarType } from "./descriptors.js"; +import { scalarZeroValue } from "./reflect/scalar.js"; +import { reflect } from "./reflect/reflect.js"; +import { BinaryReader, WireType } from "./wire/binary-encoding.js"; +import { varint32write } from "./wire/varint.js"; +// Default options for parsing binary data. +const readDefaults = { + readUnknownFields: true, +}; +function makeReadOptions(options) { + return options ? Object.assign(Object.assign({}, readDefaults), options) : readDefaults; +} +/** + * Parse serialized binary data. + */ +export function fromBinary(schema, bytes, options) { + const msg = reflect(schema, undefined, false); + readMessage(msg, new BinaryReader(bytes), makeReadOptions(options), false, bytes.byteLength); + return msg.message; +} +/** + * Parse from binary data, merging fields. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ +export function mergeFromBinary(schema, target, bytes, options) { + readMessage(reflect(schema, target, false), new BinaryReader(bytes), makeReadOptions(options), false, bytes.byteLength); + return target; +} +/** + * If `delimited` is false, read the length given in `lengthOrDelimitedFieldNo`. + * + * If `delimited` is true, read until an EndGroup tag. `lengthOrDelimitedFieldNo` + * is the expected field number. + * + * @private + */ +function readMessage(message, reader, options, delimited, lengthOrDelimitedFieldNo) { + var _a; + const end = delimited ? reader.len : reader.pos + lengthOrDelimitedFieldNo; + let fieldNo; + let wireType; + const unknownFields = (_a = message.getUnknown()) !== null && _a !== void 0 ? _a : []; + while (reader.pos < end) { + [fieldNo, wireType] = reader.tag(); + if (delimited && wireType == WireType.EndGroup) { + break; + } + const field = message.findNumber(fieldNo); + if (!field) { + const data = reader.skip(wireType, fieldNo); + if (options.readUnknownFields) { + unknownFields.push({ no: fieldNo, wireType, data }); + } + continue; + } + readField(message, reader, field, wireType, options); + } + if (delimited) { + if (wireType != WireType.EndGroup || fieldNo !== lengthOrDelimitedFieldNo) { + throw new Error("invalid end group tag"); + } + } + if (unknownFields.length > 0) { + message.setUnknown(unknownFields); + } +} +/** + * @private + */ +export function readField(message, reader, field, wireType, options) { + var _a; + switch (field.fieldKind) { + case "scalar": + message.set(field, readScalar(reader, field.scalar)); + break; + case "enum": + const val = readScalar(reader, ScalarType.INT32); + if (field.enum.open) { + message.set(field, val); + } + else { + const ok = field.enum.values.some((v) => v.number === val); + if (ok) { + message.set(field, val); + } + else if (options.readUnknownFields) { + const bytes = []; + varint32write(val, bytes); + const unknownFields = (_a = message.getUnknown()) !== null && _a !== void 0 ? _a : []; + unknownFields.push({ + no: field.number, + wireType, + data: new Uint8Array(bytes), + }); + message.setUnknown(unknownFields); + } + } + break; + case "message": + message.set(field, readMessageField(reader, options, field, message.get(field))); + break; + case "list": + readListField(reader, wireType, message.get(field), options); + break; + case "map": + readMapEntry(reader, message.get(field), options); + break; + } +} +// Read a map field, expecting key field = 1, value field = 2 +function readMapEntry(reader, map, options) { + const field = map.field(); + let key; + let val; + // Read the length of the map entry, which is a varint. + const len = reader.uint32(); + // WARNING: Calculate end AFTER advancing reader.pos (above), so that + // reader.pos is at the start of the map entry. + const end = reader.pos + len; + while (reader.pos < end) { + const [fieldNo] = reader.tag(); + switch (fieldNo) { + case 1: + key = readScalar(reader, field.mapKey); + break; + case 2: + switch (field.mapKind) { + case "scalar": + val = readScalar(reader, field.scalar); + break; + case "enum": + val = reader.int32(); + break; + case "message": + val = readMessageField(reader, options, field); + break; + } + break; + } + } + if (key === undefined) { + key = scalarZeroValue(field.mapKey, false); + } + if (val === undefined) { + switch (field.mapKind) { + case "scalar": + val = scalarZeroValue(field.scalar, false); + break; + case "enum": + val = field.enum.values[0].number; + break; + case "message": + val = reflect(field.message, undefined, false); + break; + } + } + map.set(key, val); +} +function readListField(reader, wireType, list, options) { + var _a; + const field = list.field(); + if (field.listKind === "message") { + list.add(readMessageField(reader, options, field)); + return; + } + const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32; + const packed = wireType == WireType.LengthDelimited && + scalarType != ScalarType.STRING && + scalarType != ScalarType.BYTES; + if (!packed) { + list.add(readScalar(reader, scalarType)); + return; + } + const e = reader.uint32() + reader.pos; + while (reader.pos < e) { + list.add(readScalar(reader, scalarType)); + } +} +function readMessageField(reader, options, field, mergeMessage) { + const delimited = field.delimitedEncoding; + const message = mergeMessage !== null && mergeMessage !== void 0 ? mergeMessage : reflect(field.message, undefined, false); + readMessage(message, reader, options, delimited, delimited ? field.number : reader.uint32()); + return message; +} +function readScalar(reader, type) { + switch (type) { + case ScalarType.STRING: + return reader.string(); + case ScalarType.BOOL: + return reader.bool(); + case ScalarType.DOUBLE: + return reader.double(); + case ScalarType.FLOAT: + return reader.float(); + case ScalarType.INT32: + return reader.int32(); + case ScalarType.INT64: + return reader.int64(); + case ScalarType.UINT64: + return reader.uint64(); + case ScalarType.FIXED64: + return reader.fixed64(); + case ScalarType.BYTES: + return reader.bytes(); + case ScalarType.FIXED32: + return reader.fixed32(); + case ScalarType.SFIXED32: + return reader.sfixed32(); + case ScalarType.SFIXED64: + return reader.sfixed64(); + case ScalarType.SINT64: + return reader.sint64(); + case ScalarType.UINT32: + return reader.uint32(); + case ScalarType.SINT32: + return reader.sint32(); + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/from-json.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/from-json.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..06f4d6c17928a8fa36d22247baea8528f58e5d8c --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/from-json.d.ts @@ -0,0 +1,56 @@ +import { type DescEnum, type DescMessage } from "./descriptors.js"; +import type { JsonValue } from "./json-value.js"; +import type { Registry } from "./registry.js"; +import type { EnumJsonType, EnumShape, MessageShape } from "./types.js"; +/** + * Options for parsing JSON data. + */ +export interface JsonReadOptions { + /** + * Ignore unknown fields: Proto3 JSON parser should reject unknown fields + * by default. This option ignores unknown fields in parsing, as well as + * unrecognized enum string representations. + */ + ignoreUnknownFields: boolean; + /** + * This option is required to read `google.protobuf.Any` and extensions + * from JSON format. + */ + registry?: Registry; +} +/** + * Parse a message from a JSON string. + */ +export declare function fromJsonString(schema: Desc, json: string, options?: Partial): MessageShape; +/** + * Parse a message from a JSON string, merging fields. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ +export declare function mergeFromJsonString(schema: Desc, target: MessageShape, json: string, options?: Partial): MessageShape; +/** + * Parse a message from a JSON value. + */ +export declare function fromJson(schema: Desc, json: JsonValue, options?: Partial): MessageShape; +/** + * Parse a message from a JSON value, merging fields. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ +export declare function mergeFromJson(schema: Desc, target: MessageShape, json: JsonValue, options?: Partial): MessageShape; +/** + * Parses an enum value from JSON. + */ +export declare function enumFromJson(descEnum: Desc, json: EnumJsonType): EnumShape; +/** + * Is the given value a JSON enum value? + */ +export declare function isEnumJson(descEnum: Desc, value: unknown): value is EnumJsonType; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/from-json.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/from-json.js new file mode 100644 index 0000000000000000000000000000000000000000..29ed9e0b38e1573041697e8cde7e4087c6e15ed1 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/from-json.js @@ -0,0 +1,614 @@ +// Copyright 2021-2025 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. +import { ScalarType, } from "./descriptors.js"; +import { protoInt64 } from "./proto-int64.js"; +import { create } from "./create.js"; +import { reflect } from "./reflect/reflect.js"; +import { FieldError, isFieldError } from "./reflect/error.js"; +import { formatVal } from "./reflect/reflect-check.js"; +import { scalarZeroValue } from "./reflect/scalar.js"; +import { base64Decode } from "./wire/base64-encoding.js"; +import { isWrapperDesc, anyPack, ListValueSchema, NullValue, StructSchema, ValueSchema, } from "./wkt/index.js"; +import { createExtensionContainer, setExtension } from "./extensions.js"; +// Default options for parsing JSON. +const jsonReadDefaults = { + ignoreUnknownFields: false, +}; +function makeReadOptions(options) { + return options ? Object.assign(Object.assign({}, jsonReadDefaults), options) : jsonReadDefaults; +} +/** + * Parse a message from a JSON string. + */ +export function fromJsonString(schema, json, options) { + return fromJson(schema, parseJsonString(json, schema.typeName), options); +} +/** + * Parse a message from a JSON string, merging fields. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ +export function mergeFromJsonString(schema, target, json, options) { + return mergeFromJson(schema, target, parseJsonString(json, schema.typeName), options); +} +/** + * Parse a message from a JSON value. + */ +export function fromJson(schema, json, options) { + const msg = reflect(schema); + try { + readMessage(msg, json, makeReadOptions(options)); + } + catch (e) { + if (isFieldError(e)) { + // @ts-expect-error we use the ES2022 error CTOR option "cause" for better stack traces + throw new Error(`cannot decode ${e.field()} from JSON: ${e.message}`, { + cause: e, + }); + } + throw e; + } + return msg.message; +} +/** + * Parse a message from a JSON value, merging fields. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ +export function mergeFromJson(schema, target, json, options) { + try { + readMessage(reflect(schema, target), json, makeReadOptions(options)); + } + catch (e) { + if (isFieldError(e)) { + // @ts-expect-error we use the ES2022 error CTOR option "cause" for better stack traces + throw new Error(`cannot decode ${e.field()} from JSON: ${e.message}`, { + cause: e, + }); + } + throw e; + } + return target; +} +/** + * Parses an enum value from JSON. + */ +export function enumFromJson(descEnum, json) { + const val = readEnum(descEnum, json, false, false); + if (val === tokenIgnoredUnknownEnum) { + throw new Error(`cannot decode ${descEnum} from JSON: ${formatVal(json)}`); + } + return val; +} +/** + * Is the given value a JSON enum value? + */ +export function isEnumJson(descEnum, value) { + return undefined !== descEnum.values.find((v) => v.name === value); +} +function readMessage(msg, json, opts) { + var _a; + if (tryWktFromJson(msg, json, opts)) { + return; + } + if (json == null || Array.isArray(json) || typeof json != "object") { + throw new Error(`cannot decode ${msg.desc} from JSON: ${formatVal(json)}`); + } + const oneofSeen = new Map(); + const jsonNames = new Map(); + for (const field of msg.desc.fields) { + jsonNames.set(field.name, field).set(field.jsonName, field); + } + for (const [jsonKey, jsonValue] of Object.entries(json)) { + const field = jsonNames.get(jsonKey); + if (field) { + if (field.oneof) { + if (jsonValue === null && field.fieldKind == "scalar") { + // see conformance test Required.Proto3.JsonInput.OneofFieldNull{First,Second} + continue; + } + const seen = oneofSeen.get(field.oneof); + if (seen !== undefined) { + throw new FieldError(field.oneof, `oneof set multiple times by ${seen.name} and ${field.name}`); + } + oneofSeen.set(field.oneof, field); + } + readField(msg, field, jsonValue, opts); + } + else { + let extension = undefined; + if (jsonKey.startsWith("[") && + jsonKey.endsWith("]") && + // biome-ignore lint/suspicious/noAssignInExpressions: no + (extension = (_a = opts.registry) === null || _a === void 0 ? void 0 : _a.getExtension(jsonKey.substring(1, jsonKey.length - 1))) && + extension.extendee.typeName === msg.desc.typeName) { + const [container, field, get] = createExtensionContainer(extension); + readField(container, field, jsonValue, opts); + setExtension(msg.message, extension, get()); + } + if (!extension && !opts.ignoreUnknownFields) { + throw new Error(`cannot decode ${msg.desc} from JSON: key "${jsonKey}" is unknown`); + } + } + } +} +function readField(msg, field, json, opts) { + switch (field.fieldKind) { + case "scalar": + readScalarField(msg, field, json); + break; + case "enum": + readEnumField(msg, field, json, opts); + break; + case "message": + readMessageField(msg, field, json, opts); + break; + case "list": + readListField(msg.get(field), json, opts); + break; + case "map": + readMapField(msg.get(field), json, opts); + break; + } +} +function readMapField(map, json, opts) { + if (json === null) { + return; + } + const field = map.field(); + if (typeof json != "object" || Array.isArray(json)) { + throw new FieldError(field, "expected object, got " + formatVal(json)); + } + for (const [jsonMapKey, jsonMapValue] of Object.entries(json)) { + if (jsonMapValue === null) { + throw new FieldError(field, "map value must not be null"); + } + let value; + switch (field.mapKind) { + case "message": + const msgValue = reflect(field.message); + readMessage(msgValue, jsonMapValue, opts); + value = msgValue; + break; + case "enum": + value = readEnum(field.enum, jsonMapValue, opts.ignoreUnknownFields, true); + if (value === tokenIgnoredUnknownEnum) { + return; + } + break; + case "scalar": + value = scalarFromJson(field, jsonMapValue, true); + break; + } + const key = mapKeyFromJson(field.mapKey, jsonMapKey); + map.set(key, value); + } +} +function readListField(list, json, opts) { + if (json === null) { + return; + } + const field = list.field(); + if (!Array.isArray(json)) { + throw new FieldError(field, "expected Array, got " + formatVal(json)); + } + for (const jsonItem of json) { + if (jsonItem === null) { + throw new FieldError(field, "list item must not be null"); + } + switch (field.listKind) { + case "message": + const msgValue = reflect(field.message); + readMessage(msgValue, jsonItem, opts); + list.add(msgValue); + break; + case "enum": + const enumValue = readEnum(field.enum, jsonItem, opts.ignoreUnknownFields, true); + if (enumValue !== tokenIgnoredUnknownEnum) { + list.add(enumValue); + } + break; + case "scalar": + list.add(scalarFromJson(field, jsonItem, true)); + break; + } + } +} +function readMessageField(msg, field, json, opts) { + if (json === null && field.message.typeName != "google.protobuf.Value") { + msg.clear(field); + return; + } + const msgValue = msg.isSet(field) ? msg.get(field) : reflect(field.message); + readMessage(msgValue, json, opts); + msg.set(field, msgValue); +} +function readEnumField(msg, field, json, opts) { + const enumValue = readEnum(field.enum, json, opts.ignoreUnknownFields, false); + if (enumValue === tokenNull) { + msg.clear(field); + } + else if (enumValue !== tokenIgnoredUnknownEnum) { + msg.set(field, enumValue); + } +} +function readScalarField(msg, field, json) { + const scalarValue = scalarFromJson(field, json, false); + if (scalarValue === tokenNull) { + msg.clear(field); + } + else { + msg.set(field, scalarValue); + } +} +const tokenIgnoredUnknownEnum = Symbol(); +function readEnum(desc, json, ignoreUnknownFields, nullAsZeroValue) { + if (json === null) { + if (desc.typeName == "google.protobuf.NullValue") { + return 0; // google.protobuf.NullValue.NULL_VALUE = 0 + } + return nullAsZeroValue ? desc.values[0].number : tokenNull; + } + switch (typeof json) { + case "number": + if (Number.isInteger(json)) { + return json; + } + break; + case "string": + const value = desc.values.find((ev) => ev.name === json); + if (value !== undefined) { + return value.number; + } + if (ignoreUnknownFields) { + return tokenIgnoredUnknownEnum; + } + break; + } + throw new Error(`cannot decode ${desc} from JSON: ${formatVal(json)}`); +} +const tokenNull = Symbol(); +function scalarFromJson(field, json, nullAsZeroValue) { + if (json === null) { + if (nullAsZeroValue) { + return scalarZeroValue(field.scalar, false); + } + return tokenNull; + } + // int64, sfixed64, sint64, fixed64, uint64: Reflect supports string and number. + // string, bool: Supported by reflect. + switch (field.scalar) { + // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity". + // Either numbers or strings are accepted. Exponent notation is also accepted. + case ScalarType.DOUBLE: + case ScalarType.FLOAT: + if (json === "NaN") + return NaN; + if (json === "Infinity") + return Number.POSITIVE_INFINITY; + if (json === "-Infinity") + return Number.NEGATIVE_INFINITY; + if (typeof json == "number") { + if (Number.isNaN(json)) { + // NaN must be encoded with string constants + throw new FieldError(field, "unexpected NaN number"); + } + if (!Number.isFinite(json)) { + // Infinity must be encoded with string constants + throw new FieldError(field, "unexpected infinite number"); + } + break; + } + if (typeof json == "string") { + if (json === "") { + // empty string is not a number + break; + } + if (json.trim().length !== json.length) { + // extra whitespace + break; + } + const float = Number(json); + if (!Number.isFinite(float)) { + // Infinity and NaN must be encoded with string constants + break; + } + return float; + } + break; + // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted. + case ScalarType.INT32: + case ScalarType.FIXED32: + case ScalarType.SFIXED32: + case ScalarType.SINT32: + case ScalarType.UINT32: + return int32FromJson(json); + // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings. + // Either standard or URL-safe base64 encoding with/without paddings are accepted. + case ScalarType.BYTES: + if (typeof json == "string") { + if (json === "") { + return new Uint8Array(0); + } + try { + return base64Decode(json); + } + catch (e) { + const message = e instanceof Error ? e.message : String(e); + throw new FieldError(field, message); + } + } + break; + } + return json; +} +/** + * Try to parse a JSON value to a map key for the reflect API. + * + * Returns the input if the JSON value cannot be converted. + */ +function mapKeyFromJson(type, json) { + switch (type) { + case ScalarType.BOOL: + switch (json) { + case "true": + return true; + case "false": + return false; + } + return json; + case ScalarType.INT32: + case ScalarType.FIXED32: + case ScalarType.UINT32: + case ScalarType.SFIXED32: + case ScalarType.SINT32: + return int32FromJson(json); + default: + return json; + } +} +/** + * Try to parse a JSON value to a 32-bit integer for the reflect API. + * + * Returns the input if the JSON value cannot be converted. + */ +function int32FromJson(json) { + if (typeof json == "string") { + if (json === "") { + // empty string is not a number + return json; + } + if (json.trim().length !== json.length) { + // extra whitespace + return json; + } + const num = Number(json); + if (Number.isNaN(num)) { + // not a number + return json; + } + return num; + } + return json; +} +function parseJsonString(jsonString, typeName) { + try { + return JSON.parse(jsonString); + } + catch (e) { + const message = e instanceof Error ? e.message : String(e); + throw new Error(`cannot decode message ${typeName} from JSON: ${message}`, + // @ts-expect-error we use the ES2022 error CTOR option "cause" for better stack traces + { cause: e }); + } +} +function tryWktFromJson(msg, jsonValue, opts) { + if (!msg.desc.typeName.startsWith("google.protobuf.")) { + return false; + } + switch (msg.desc.typeName) { + case "google.protobuf.Any": + anyFromJson(msg.message, jsonValue, opts); + return true; + case "google.protobuf.Timestamp": + timestampFromJson(msg.message, jsonValue); + return true; + case "google.protobuf.Duration": + durationFromJson(msg.message, jsonValue); + return true; + case "google.protobuf.FieldMask": + fieldMaskFromJson(msg.message, jsonValue); + return true; + case "google.protobuf.Struct": + structFromJson(msg.message, jsonValue); + return true; + case "google.protobuf.Value": + valueFromJson(msg.message, jsonValue); + return true; + case "google.protobuf.ListValue": + listValueFromJson(msg.message, jsonValue); + return true; + default: + if (isWrapperDesc(msg.desc)) { + const valueField = msg.desc.fields[0]; + if (jsonValue === null) { + msg.clear(valueField); + } + else { + msg.set(valueField, scalarFromJson(valueField, jsonValue, true)); + } + return true; + } + return false; + } +} +function anyFromJson(any, json, opts) { + var _a; + if (json === null || Array.isArray(json) || typeof json != "object") { + throw new Error(`cannot decode message ${any.$typeName} from JSON: expected object but got ${formatVal(json)}`); + } + if (Object.keys(json).length == 0) { + return; + } + const typeUrl = json["@type"]; + if (typeof typeUrl != "string" || typeUrl == "") { + throw new Error(`cannot decode message ${any.$typeName} from JSON: "@type" is empty`); + } + const typeName = typeUrl.includes("/") + ? typeUrl.substring(typeUrl.lastIndexOf("/") + 1) + : typeUrl; + if (!typeName.length) { + throw new Error(`cannot decode message ${any.$typeName} from JSON: "@type" is invalid`); + } + const desc = (_a = opts.registry) === null || _a === void 0 ? void 0 : _a.getMessage(typeName); + if (!desc) { + throw new Error(`cannot decode message ${any.$typeName} from JSON: ${typeUrl} is not in the type registry`); + } + const msg = reflect(desc); + if (typeName.startsWith("google.protobuf.") && + Object.prototype.hasOwnProperty.call(json, "value")) { + const value = json.value; + readMessage(msg, value, opts); + } + else { + const copy = Object.assign({}, json); + // biome-ignore lint/performance/noDelete: + delete copy["@type"]; + readMessage(msg, copy, opts); + } + anyPack(msg.desc, msg.message, any); +} +function timestampFromJson(timestamp, json) { + if (typeof json !== "string") { + throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: ${formatVal(json)}`); + } + const matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\.([0-9]{1,9}))?(?:Z|([+-][0-9][0-9]:[0-9][0-9]))$/); + if (!matches) { + throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: invalid RFC 3339 string`); + } + const ms = Date.parse( + // biome-ignore format: want this to read well + matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z")); + if (Number.isNaN(ms)) { + throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: invalid RFC 3339 string`); + } + if (ms < Date.parse("0001-01-01T00:00:00Z") || + ms > Date.parse("9999-12-31T23:59:59Z")) { + throw new Error(`cannot decode message ${timestamp.$typeName} from JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`); + } + timestamp.seconds = protoInt64.parse(ms / 1000); + timestamp.nanos = 0; + if (matches[7]) { + timestamp.nanos = + parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) - + 1000000000; + } +} +function durationFromJson(duration, json) { + if (typeof json !== "string") { + throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${formatVal(json)}`); + } + const match = json.match(/^(-?[0-9]+)(?:\.([0-9]+))?s/); + if (match === null) { + throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${formatVal(json)}`); + } + const longSeconds = Number(match[1]); + if (longSeconds > 315576000000 || longSeconds < -315576000000) { + throw new Error(`cannot decode message ${duration.$typeName} from JSON: ${formatVal(json)}`); + } + duration.seconds = protoInt64.parse(longSeconds); + if (typeof match[2] !== "string") { + return; + } + const nanosStr = match[2] + "0".repeat(9 - match[2].length); + duration.nanos = parseInt(nanosStr); + if (longSeconds < 0 || Object.is(longSeconds, -0)) { + duration.nanos = -duration.nanos; + } +} +function fieldMaskFromJson(fieldMask, json) { + if (typeof json !== "string") { + throw new Error(`cannot decode message ${fieldMask.$typeName} from JSON: ${formatVal(json)}`); + } + if (json === "") { + return; + } + function camelToSnake(str) { + if (str.includes("_")) { + throw new Error(`cannot decode message ${fieldMask.$typeName} from JSON: path names must be lowerCamelCase`); + } + const sc = str.replace(/[A-Z]/g, (letter) => "_" + letter.toLowerCase()); + return sc[0] === "_" ? sc.substring(1) : sc; + } + fieldMask.paths = json.split(",").map(camelToSnake); +} +function structFromJson(struct, json) { + if (typeof json != "object" || json == null || Array.isArray(json)) { + throw new Error(`cannot decode message ${struct.$typeName} from JSON ${formatVal(json)}`); + } + for (const [k, v] of Object.entries(json)) { + const parsedV = create(ValueSchema); + valueFromJson(parsedV, v); + struct.fields[k] = parsedV; + } +} +function valueFromJson(value, json) { + switch (typeof json) { + case "number": + value.kind = { case: "numberValue", value: json }; + break; + case "string": + value.kind = { case: "stringValue", value: json }; + break; + case "boolean": + value.kind = { case: "boolValue", value: json }; + break; + case "object": + if (json === null) { + value.kind = { case: "nullValue", value: NullValue.NULL_VALUE }; + } + else if (Array.isArray(json)) { + const listValue = create(ListValueSchema); + listValueFromJson(listValue, json); + value.kind = { case: "listValue", value: listValue }; + } + else { + const struct = create(StructSchema); + structFromJson(struct, json); + value.kind = { case: "structValue", value: struct }; + } + break; + default: + throw new Error(`cannot decode message ${value.$typeName} from JSON ${formatVal(json)}`); + } + return value; +} +function listValueFromJson(listValue, json) { + if (!Array.isArray(json)) { + throw new Error(`cannot decode message ${listValue.$typeName} from JSON ${formatVal(json)}`); + } + for (const e of json) { + const value = create(ValueSchema); + valueFromJson(value, e); + listValue.values.push(value); + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/index.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7a23115160415ba30f14f8cfe66be6bc92bb2a32 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/index.d.ts @@ -0,0 +1,18 @@ +export * from "./types.js"; +export * from "./is-message.js"; +export * from "./create.js"; +export * from "./clone.js"; +export * from "./descriptors.js"; +export * from "./equals.js"; +export * from "./fields.js"; +export * from "./registry.js"; +export type { JsonValue, JsonObject } from "./json-value.js"; +export { toBinary } from "./to-binary.js"; +export type { BinaryWriteOptions } from "./to-binary.js"; +export { fromBinary, mergeFromBinary } from "./from-binary.js"; +export type { BinaryReadOptions } from "./from-binary.js"; +export * from "./to-json.js"; +export * from "./from-json.js"; +export * from "./merge.js"; +export { hasExtension, getExtension, setExtension, clearExtension, hasOption, getOption, } from "./extensions.js"; +export * from "./proto-int64.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/index.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/index.js new file mode 100644 index 0000000000000000000000000000000000000000..5f79001fea9cf14550d6adeb488e9236af7bae98 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/index.js @@ -0,0 +1,28 @@ +// Copyright 2021-2025 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. +export * from "./types.js"; +export * from "./is-message.js"; +export * from "./create.js"; +export * from "./clone.js"; +export * from "./descriptors.js"; +export * from "./equals.js"; +export * from "./fields.js"; +export * from "./registry.js"; +export { toBinary } from "./to-binary.js"; +export { fromBinary, mergeFromBinary } from "./from-binary.js"; +export * from "./to-json.js"; +export * from "./from-json.js"; +export * from "./merge.js"; +export { hasExtension, getExtension, setExtension, clearExtension, hasOption, getOption, } from "./extensions.js"; +export * from "./proto-int64.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/is-message.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/is-message.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..085782d5d1d8ed73a4f6cebda7348822bcddab04 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/is-message.d.ts @@ -0,0 +1,7 @@ +import type { MessageShape } from "./types.js"; +import type { DescMessage } from "./descriptors.js"; +/** + * Determine whether the given `arg` is a message. + * If `desc` is set, determine whether `arg` is this specific message. + */ +export declare function isMessage(arg: unknown, schema?: Desc): arg is MessageShape; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/is-message.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/is-message.js new file mode 100644 index 0000000000000000000000000000000000000000..2a05b5d38f597d0961238a06734fa1bc57c07f95 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/is-message.js @@ -0,0 +1,30 @@ +// Copyright 2021-2025 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. +/** + * Determine whether the given `arg` is a message. + * If `desc` is set, determine whether `arg` is this specific message. + */ +export function isMessage(arg, schema) { + const isMessage = arg !== null && + typeof arg == "object" && + "$typeName" in arg && + typeof arg.$typeName == "string"; + if (!isMessage) { + return false; + } + if (schema === undefined) { + return true; + } + return schema.typeName === arg.$typeName; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/json-value.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/json-value.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3857eb8d4e19a46687b68f041fdddb47824f680a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/json-value.d.ts @@ -0,0 +1,16 @@ +/** + * Represents any possible JSON value: + * - number + * - string + * - boolean + * - null + * - object (with any JSON value as property) + * - array (with any JSON value as element) + */ +export type JsonValue = number | string | boolean | null | JsonObject | JsonValue[]; +/** + * Represents a JSON object. + */ +export type JsonObject = { + [k: string]: JsonValue; +}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/json-value.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/json-value.js new file mode 100644 index 0000000000000000000000000000000000000000..f9c447989619ad243c8fb60cf167ed1be96ee713 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/json-value.js @@ -0,0 +1,14 @@ +// Copyright 2021-2025 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. +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/merge.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/merge.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..aad01ed042172fd239ff8bbe0fb971604a4bab0a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/merge.d.ts @@ -0,0 +1,13 @@ +import type { MessageShape } from "./types.js"; +import type { DescMessage } from "./descriptors.js"; +/** + * Merge message `source` into message `target`, following Protobuf semantics. + * + * This is the same as serializing the source message, then deserializing it + * into the target message via `mergeFromBinary()`, with one difference: + * While serialization will create a copy of all values, `merge()` will copy + * the reference for `bytes` and messages. + * + * Also see https://protobuf.com/docs/language-spec#merging-protobuf-messages + */ +export declare function merge(schema: Desc, target: MessageShape, source: MessageShape): void; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/merge.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/merge.js new file mode 100644 index 0000000000000000000000000000000000000000..16efbba31799a5ac9061da44faa97bb04193d4fd --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/merge.js @@ -0,0 +1,67 @@ +// Copyright 2021-2025 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. +import { reflect } from "./reflect/reflect.js"; +/** + * Merge message `source` into message `target`, following Protobuf semantics. + * + * This is the same as serializing the source message, then deserializing it + * into the target message via `mergeFromBinary()`, with one difference: + * While serialization will create a copy of all values, `merge()` will copy + * the reference for `bytes` and messages. + * + * Also see https://protobuf.com/docs/language-spec#merging-protobuf-messages + */ +export function merge(schema, target, source) { + reflectMerge(reflect(schema, target), reflect(schema, source)); +} +function reflectMerge(target, source) { + var _a; + var _b; + const sourceUnknown = source.message.$unknown; + if (sourceUnknown !== undefined && sourceUnknown.length > 0) { + (_a = (_b = target.message).$unknown) !== null && _a !== void 0 ? _a : (_b.$unknown = []); + target.message.$unknown.push(...sourceUnknown); + } + for (const f of target.fields) { + if (!source.isSet(f)) { + continue; + } + switch (f.fieldKind) { + case "scalar": + case "enum": + target.set(f, source.get(f)); + break; + case "message": + if (target.isSet(f)) { + reflectMerge(target.get(f), source.get(f)); + } + else { + target.set(f, source.get(f)); + } + break; + case "list": + const list = target.get(f); + for (const e of source.get(f)) { + list.add(e); + } + break; + case "map": + const map = target.get(f); + for (const [k, v] of source.get(f)) { + map.set(k, v); + } + break; + } + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/proto-int64.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/proto-int64.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3eaf231a9724e09334df9c3b1c4dc152c05dd7e7 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/proto-int64.d.ts @@ -0,0 +1,98 @@ +/** + * Int64Support for the current environment. + */ +export declare const protoInt64: Int64Support; +/** + * We use the `bigint` primitive to represent 64-bit integral types. If bigint + * is unavailable, we fall back to a string representation, which means that + * all values typed as `bigint` will actually be strings. + * + * If your code is intended to run in an environment where bigint may be + * unavailable, it must handle both the bigint and the string representation. + * For presenting values, this is straight-forward with implicit or explicit + * conversion to string: + * + * ```ts + * let el = document.createElement("span"); + * el.innerText = message.int64Field; // assuming a protobuf int64 field + * + * console.log(`int64: ${message.int64Field}`); + * + * let str: string = message.int64Field.toString(); + * ``` + * + * If you need to manipulate 64-bit integral values and are sure the values + * can be safely represented as an IEEE-754 double precision number, you can + * convert to a JavaScript Number: + * + * ```ts + * console.log(message.int64Field.toString()) + * let num = Number(message.int64Field); + * num = num + 1; + * message.int64Field = protoInt64.parse(num); + * ``` + * + * If you need to manipulate 64-bit integral values that are outside the + * range of safe representation as a JavaScript Number, we recommend you + * use a third party library, for example the npm package "long": + * + * ```ts + * // convert the field value to a Long + * const bits = protoInt64.enc(message.int64Field); + * const longValue = Long.fromBits(bits.lo, bits.hi); + * + * // perform arithmetic + * const longResult = longValue.subtract(1); + * + * // set the result in the field + * message.int64Field = protoInt64.dec(longResult.low, longResult.high); + * + * // Assuming int64Field contains 9223372036854775807: + * console.log(message.int64Field); // 9223372036854775806 + * ``` + */ +interface Int64Support { + /** + * 0n if bigint is available, "0" if unavailable. + */ + readonly zero: bigint; + /** + * Is bigint available? + */ + readonly supported: boolean; + /** + * Parse a signed 64-bit integer. + * Returns a bigint if available, a string otherwise. + */ + parse(value: string | number | bigint): bigint; + /** + * Parse an unsigned 64-bit integer. + * Returns a bigint if available, a string otherwise. + */ + uParse(value: string | number | bigint): bigint; + /** + * Convert a signed 64-bit integral value to a two's complement. + */ + enc(value: string | number | bigint): { + lo: number; + hi: number; + }; + /** + * Convert an unsigned 64-bit integral value to a two's complement. + */ + uEnc(value: string | number | bigint): { + lo: number; + hi: number; + }; + /** + * Convert a two's complement to a signed 64-bit integral value. + * Returns a bigint if available, a string otherwise. + */ + dec(lo: number, hi: number): bigint; + /** + * Convert a two's complement to an unsigned 64-bit integral value. + * Returns a bigint if available, a string otherwise. + */ + uDec(lo: number, hi: number): bigint; +} +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/proto-int64.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/proto-int64.js new file mode 100644 index 0000000000000000000000000000000000000000..70cf4919d74fae4d18ad08706b7f3c5545e9f605 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/proto-int64.js @@ -0,0 +1,126 @@ +// Copyright 2021-2025 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. +import { int64FromString, int64ToString, uInt64ToString, } from "./wire/varint.js"; +/** + * Int64Support for the current environment. + */ +export const protoInt64 = /*@__PURE__*/ makeInt64Support(); +function makeInt64Support() { + const dv = new DataView(new ArrayBuffer(8)); + // note that Safari 14 implements BigInt, but not the DataView methods + const ok = typeof BigInt === "function" && + typeof dv.getBigInt64 === "function" && + typeof dv.getBigUint64 === "function" && + typeof dv.setBigInt64 === "function" && + typeof dv.setBigUint64 === "function" && + (typeof process != "object" || + typeof process.env != "object" || + process.env.BUF_BIGINT_DISABLE !== "1"); + if (ok) { + const MIN = BigInt("-9223372036854775808"); + const MAX = BigInt("9223372036854775807"); + const UMIN = BigInt("0"); + const UMAX = BigInt("18446744073709551615"); + return { + zero: BigInt(0), + supported: true, + parse(value) { + const bi = typeof value == "bigint" ? value : BigInt(value); + if (bi > MAX || bi < MIN) { + throw new Error(`invalid int64: ${value}`); + } + return bi; + }, + uParse(value) { + const bi = typeof value == "bigint" ? value : BigInt(value); + if (bi > UMAX || bi < UMIN) { + throw new Error(`invalid uint64: ${value}`); + } + return bi; + }, + enc(value) { + dv.setBigInt64(0, this.parse(value), true); + return { + lo: dv.getInt32(0, true), + hi: dv.getInt32(4, true), + }; + }, + uEnc(value) { + dv.setBigInt64(0, this.uParse(value), true); + return { + lo: dv.getInt32(0, true), + hi: dv.getInt32(4, true), + }; + }, + dec(lo, hi) { + dv.setInt32(0, lo, true); + dv.setInt32(4, hi, true); + return dv.getBigInt64(0, true); + }, + uDec(lo, hi) { + dv.setInt32(0, lo, true); + dv.setInt32(4, hi, true); + return dv.getBigUint64(0, true); + }, + }; + } + return { + zero: "0", + supported: false, + parse(value) { + if (typeof value != "string") { + value = value.toString(); + } + assertInt64String(value); + return value; + }, + uParse(value) { + if (typeof value != "string") { + value = value.toString(); + } + assertUInt64String(value); + return value; + }, + enc(value) { + if (typeof value != "string") { + value = value.toString(); + } + assertInt64String(value); + return int64FromString(value); + }, + uEnc(value) { + if (typeof value != "string") { + value = value.toString(); + } + assertUInt64String(value); + return int64FromString(value); + }, + dec(lo, hi) { + return int64ToString(lo, hi); + }, + uDec(lo, hi) { + return uInt64ToString(lo, hi); + }, + }; +} +function assertInt64String(value) { + if (!/^-?[0-9]+$/.test(value)) { + throw new Error("invalid int64: " + value); + } +} +function assertUInt64String(value) { + if (!/^[0-9]+$/.test(value)) { + throw new Error("invalid uint64: " + value); + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/error.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/error.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c6bf1db0e4431a962daa8125489afad049029ea2 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/error.d.ts @@ -0,0 +1,9 @@ +import type { DescField, DescOneof } from "../descriptors.js"; +declare const errorNames: string[]; +export declare class FieldError extends Error { + readonly name: (typeof errorNames)[number]; + constructor(fieldOrOneof: DescField | DescOneof, message: string, name?: (typeof errorNames)[number]); + readonly field: () => DescField | DescOneof; +} +export declare function isFieldError(arg: unknown): arg is FieldError; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/error.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/error.js new file mode 100644 index 0000000000000000000000000000000000000000..c8e2bd9ea2a5e260b3cdcba6322e0d71cb5e5ec3 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/error.js @@ -0,0 +1,31 @@ +// Copyright 2021-2025 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. +const errorNames = [ + "FieldValueInvalidError", + "FieldListRangeError", + "ForeignFieldError", +]; +export class FieldError extends Error { + constructor(fieldOrOneof, message, name = "FieldValueInvalidError") { + super(message); + this.name = name; + this.field = () => fieldOrOneof; + } +} +export function isFieldError(arg) { + return (arg instanceof Error && + errorNames.includes(arg.name) && + "field" in arg && + typeof arg.field == "function"); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/guard.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/guard.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c53aeb23407a24e8f6bd7949870f36b23a2148a9 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/guard.d.ts @@ -0,0 +1,20 @@ +import type { Message } from "../types.js"; +import type { ScalarValue } from "./scalar.js"; +import type { ReflectList, ReflectMap, ReflectMessage } from "./reflect-types.js"; +import type { DescField, DescMessage } from "../descriptors.js"; +export declare function isObject(arg: unknown): arg is Record; +export declare function isOneofADT(arg: unknown): arg is OneofADT; +export type OneofADT = { + case: undefined; + value?: undefined; +} | { + case: string; + value: Message | ScalarValue; +}; +export declare function isReflectList(arg: unknown, field?: DescField & { + fieldKind: "list"; +}): arg is ReflectList; +export declare function isReflectMap(arg: unknown, field?: DescField & { + fieldKind: "map"; +}): arg is ReflectMap; +export declare function isReflectMessage(arg: unknown, messageDesc?: DescMessage): arg is ReflectMessage; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/guard.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/guard.js new file mode 100644 index 0000000000000000000000000000000000000000..4383a247492723f5bd690245435e223b9ff1511d --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/guard.js @@ -0,0 +1,71 @@ +// Copyright 2021-2025 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. +import { unsafeLocal } from "./unsafe.js"; +export function isObject(arg) { + return arg !== null && typeof arg == "object" && !Array.isArray(arg); +} +export function isOneofADT(arg) { + return (arg !== null && + typeof arg == "object" && + "case" in arg && + ((typeof arg.case == "string" && "value" in arg && arg.value != null) || + (arg.case === undefined && + (!("value" in arg) || arg.value === undefined)))); +} +export function isReflectList(arg, field) { + var _a, _b, _c, _d; + if (isObject(arg) && + unsafeLocal in arg && + "add" in arg && + "field" in arg && + typeof arg.field == "function") { + if (field !== undefined) { + const a = field; + const b = arg.field(); + return (a.listKind == b.listKind && + a.scalar === b.scalar && + ((_a = a.message) === null || _a === void 0 ? void 0 : _a.typeName) === ((_b = b.message) === null || _b === void 0 ? void 0 : _b.typeName) && + ((_c = a.enum) === null || _c === void 0 ? void 0 : _c.typeName) === ((_d = b.enum) === null || _d === void 0 ? void 0 : _d.typeName)); + } + return true; + } + return false; +} +export function isReflectMap(arg, field) { + var _a, _b, _c, _d; + if (isObject(arg) && + unsafeLocal in arg && + "has" in arg && + "field" in arg && + typeof arg.field == "function") { + if (field !== undefined) { + const a = field, b = arg.field(); + return (a.mapKey === b.mapKey && + a.mapKind == b.mapKind && + a.scalar === b.scalar && + ((_a = a.message) === null || _a === void 0 ? void 0 : _a.typeName) === ((_b = b.message) === null || _b === void 0 ? void 0 : _b.typeName) && + ((_c = a.enum) === null || _c === void 0 ? void 0 : _c.typeName) === ((_d = b.enum) === null || _d === void 0 ? void 0 : _d.typeName)); + } + return true; + } + return false; +} +export function isReflectMessage(arg, messageDesc) { + return (isObject(arg) && + unsafeLocal in arg && + "desc" in arg && + isObject(arg.desc) && + arg.desc.kind === "message" && + (messageDesc === undefined || arg.desc.typeName == messageDesc.typeName)); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/index.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..97a71306f22a348c82e645555d5ed761210fffb3 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/index.d.ts @@ -0,0 +1,8 @@ +export * from "./error.js"; +export * from "./names.js"; +export * from "./nested-types.js"; +export * from "./reflect.js"; +export * from "./reflect-types.js"; +export * from "./scalar.js"; +export * from "./path.js"; +export { isReflectList, isReflectMap, isReflectMessage } from "./guard.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/index.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/index.js new file mode 100644 index 0000000000000000000000000000000000000000..cf511c92fcbc1e5baff9e67184fe4cc59ddba228 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/index.js @@ -0,0 +1,21 @@ +// Copyright 2021-2025 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. +export * from "./error.js"; +export * from "./names.js"; +export * from "./nested-types.js"; +export * from "./reflect.js"; +export * from "./reflect-types.js"; +export * from "./scalar.js"; +export * from "./path.js"; +export { isReflectList, isReflectMap, isReflectMessage } from "./guard.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/names.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/names.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3824c63dbbaf687e4dfc9e57be050771832d4982 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/names.d.ts @@ -0,0 +1,19 @@ +import type { AnyDesc } from "../descriptors.js"; +/** + * Return a fully-qualified name for a Protobuf descriptor. + * For a file descriptor, return the original file path. + * + * See https://protobuf.com/docs/language-spec#fully-qualified-names + */ +export declare function qualifiedName(desc: AnyDesc): string; +/** + * Converts snake_case to protoCamelCase according to the convention + * used by protoc to convert a field name to a JSON name. + */ +export declare function protoCamelCase(snakeCase: string): string; +/** + * Escapes names that are reserved for ECMAScript built-in object properties. + * + * Also see safeIdentifier() from @bufbuild/protoplugin. + */ +export declare function safeObjectProperty(name: string): string; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/names.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/names.js new file mode 100644 index 0000000000000000000000000000000000000000..30d203fca5778a98df91e2a74b9b7b940ef82060 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/names.js @@ -0,0 +1,96 @@ +// Copyright 2021-2025 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. +/** + * Return a fully-qualified name for a Protobuf descriptor. + * For a file descriptor, return the original file path. + * + * See https://protobuf.com/docs/language-spec#fully-qualified-names + */ +export function qualifiedName(desc) { + switch (desc.kind) { + case "field": + case "oneof": + case "rpc": + return desc.parent.typeName + "." + desc.name; + case "enum_value": { + const p = desc.parent.parent + ? desc.parent.parent.typeName + : desc.parent.file.proto.package; + return p + (p.length > 0 ? "." : "") + desc.name; + } + case "service": + case "message": + case "enum": + case "extension": + return desc.typeName; + case "file": + return desc.proto.name; + } +} +/** + * Converts snake_case to protoCamelCase according to the convention + * used by protoc to convert a field name to a JSON name. + */ +export function protoCamelCase(snakeCase) { + let capNext = false; + const b = []; + for (let i = 0; i < snakeCase.length; i++) { + let c = snakeCase.charAt(i); + switch (c) { + case "_": + capNext = true; + break; + case "0": + case "1": + case "2": + case "3": + case "4": + case "5": + case "6": + case "7": + case "8": + case "9": + b.push(c); + capNext = false; + break; + default: + if (capNext) { + capNext = false; + c = c.toUpperCase(); + } + b.push(c); + break; + } + } + return b.join(""); +} +/** + * Names that cannot be used for object properties because they are reserved + * by built-in JavaScript properties. + */ +const reservedObjectProperties = new Set([ + // names reserved by JavaScript + "constructor", + "toString", + "toJSON", + "valueOf", +]); +/** + * Escapes names that are reserved for ECMAScript built-in object properties. + * + * Also see safeIdentifier() from @bufbuild/protoplugin. + */ +export function safeObjectProperty(name) { + return reservedObjectProperties.has(name) ? name + "$" : name; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/nested-types.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/nested-types.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3817501c613503736031d0ecae80582692a5f0ca --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/nested-types.d.ts @@ -0,0 +1,35 @@ +import type { AnyDesc, DescEnum, DescExtension, DescFile, DescMessage, DescService } from "../descriptors.js"; +/** + * Iterate over all types - enumerations, extensions, services, messages - + * and enumerations, extensions and messages nested in messages. + */ +export declare function nestedTypes(desc: DescFile | DescMessage): Iterable; +/** + * Iterate over types referenced by fields of the given message. + * + * For example: + * + * ```proto + * syntax="proto3"; + * + * message Example { + * Msg singular = 1; + * repeated Level list = 2; + * } + * + * message Msg {} + * + * enum Level { + * LEVEL_UNSPECIFIED = 0; + * } + * ``` + * + * The message Example references the message Msg, and the enum Level. + */ +export declare function usedTypes(descMessage: DescMessage): Iterable; +/** + * Returns the ancestors of a given Protobuf element, up to the file. + */ +export declare function parentTypes(desc: AnyDesc): Parent[]; +type Parent = DescFile | DescEnum | DescMessage | DescService; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/nested-types.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/nested-types.js new file mode 100644 index 0000000000000000000000000000000000000000..aeb2d20a91cd03ee101d0455c5ff3e0b4220019e --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/nested-types.js @@ -0,0 +1,105 @@ +// Copyright 2021-2025 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. +/** + * Iterate over all types - enumerations, extensions, services, messages - + * and enumerations, extensions and messages nested in messages. + */ +export function* nestedTypes(desc) { + switch (desc.kind) { + case "file": + for (const message of desc.messages) { + yield message; + yield* nestedTypes(message); + } + yield* desc.enums; + yield* desc.services; + yield* desc.extensions; + break; + case "message": + for (const message of desc.nestedMessages) { + yield message; + yield* nestedTypes(message); + } + yield* desc.nestedEnums; + yield* desc.nestedExtensions; + break; + } +} +/** + * Iterate over types referenced by fields of the given message. + * + * For example: + * + * ```proto + * syntax="proto3"; + * + * message Example { + * Msg singular = 1; + * repeated Level list = 2; + * } + * + * message Msg {} + * + * enum Level { + * LEVEL_UNSPECIFIED = 0; + * } + * ``` + * + * The message Example references the message Msg, and the enum Level. + */ +export function usedTypes(descMessage) { + return usedTypesInternal(descMessage, new Set()); +} +function* usedTypesInternal(descMessage, seen) { + var _a, _b; + for (const field of descMessage.fields) { + const ref = (_b = (_a = field.enum) !== null && _a !== void 0 ? _a : field.message) !== null && _b !== void 0 ? _b : undefined; + if (!ref || seen.has(ref.typeName)) { + continue; + } + seen.add(ref.typeName); + yield ref; + if (ref.kind == "message") { + yield* usedTypesInternal(ref, seen); + } + } +} +/** + * Returns the ancestors of a given Protobuf element, up to the file. + */ +export function parentTypes(desc) { + const parents = []; + while (desc.kind !== "file") { + const p = parent(desc); + desc = p; + parents.push(p); + } + return parents; +} +function parent(desc) { + var _a; + switch (desc.kind) { + case "enum_value": + case "field": + case "oneof": + case "rpc": + return desc.parent; + case "service": + return desc.file; + case "extension": + case "enum": + case "message": + return (_a = desc.parent) !== null && _a !== void 0 ? _a : desc.file; + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/path.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/path.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..cb352b2fe3fdb18c32fbf7d5dd48d817be5f2d1d --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/path.d.ts @@ -0,0 +1,107 @@ +import { type DescExtension, type DescField, type DescMessage, type DescOneof } from "../descriptors.js"; +import type { Registry } from "../registry.js"; +/** + * A path to a (nested) member of a Protobuf message, such as a field, oneof, + * extension, list element, or map entry. + * + * Note that we may add additional types to this union in the future to support + * more use cases. + */ +export type Path = (DescField | DescExtension | DescOneof | { + kind: "list_sub"; + index: number; +} | { + kind: "map_sub"; + key: string | number | bigint | boolean; +})[]; +/** + * Builds a Path. + */ +export type PathBuilder = { + /** + * The root message of the path. + */ + readonly schema: DescMessage; + /** + * Add field access. + * + * Throws an InvalidPathError if the field cannot be added to the path. + */ + field(field: DescField): PathBuilder; + /** + * Access a oneof. + * + * Throws an InvalidPathError if the oneof cannot be added to the path. + * + */ + oneof(oneof: DescOneof): PathBuilder; + /** + * Access an extension. + * + * Throws an InvalidPathError if the extension cannot be added to the path. + */ + extension(extension: DescExtension): PathBuilder; + /** + * Access a list field by index. + * + * Throws an InvalidPathError if the list access cannot be added to the path. + */ + list(index: number): PathBuilder; + /** + * Access a map field by key. + * + * Throws an InvalidPathError if the map access cannot be added to the path. + */ + map(key: string | number | bigint | boolean): PathBuilder; + /** + * Append a path. + * + * Throws an InvalidPathError if the path cannot be added. + */ + add(path: Path | PathBuilder): PathBuilder; + /** + * Return the path. + */ + toPath(): Path; + /** + * Create a copy of this builder. + */ + clone(): PathBuilder; + /** + * Get the current container - a list, map, or message. + */ + getLeft(): DescMessage | (DescField & { + fieldKind: "list"; + }) | (DescField & { + fieldKind: "map"; + }) | undefined; +}; +/** + * Create a PathBuilder. + */ +export declare function buildPath(schema: DescMessage): PathBuilder; +/** + * Parse a Path from a string. + * + * Throws an InvalidPathError if the path is invalid. + * + * Note that a Registry must be provided via the options argument to parse + * paths that refer to an extension. + */ +export declare function parsePath(schema: DescMessage, path: string, options?: { + registry?: Registry; +}): Path; +/** + * Stringify a path. + */ +export declare function pathToString(path: Path): string; +/** + * InvalidPathError is thrown for invalid Paths, for example during parsing from + * a string, or when a new Path is built. + */ +export declare class InvalidPathError extends Error { + name: string; + readonly schema: DescMessage; + readonly path: Path | string; + constructor(schema: DescMessage, message: string, path: string | Path); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/path.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/path.js new file mode 100644 index 0000000000000000000000000000000000000000..b412aa5db83dae3b8fd3ac5e610961ee01b7259a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/path.js @@ -0,0 +1,369 @@ +// Copyright 2021-2025 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. +import { ScalarType, } from "../descriptors.js"; +/** + * Create a PathBuilder. + */ +export function buildPath(schema) { + return new PathBuilderImpl(schema, schema, []); +} +/** + * Parse a Path from a string. + * + * Throws an InvalidPathError if the path is invalid. + * + * Note that a Registry must be provided via the options argument to parse + * paths that refer to an extension. + */ +export function parsePath(schema, path, options) { + var _a, _b; + const builder = new PathBuilderImpl(schema, schema, []); + const err = (message, i) => new InvalidPathError(schema, message + " at column " + (i + 1), path); + for (let i = 0; i < path.length;) { + const token = nextToken(i, path); + const left = builder.getLeft(); + let right = undefined; + if ("field" in token) { + right = + (left === null || left === void 0 ? void 0 : left.kind) != "message" + ? undefined + : ((_a = left.fields.find((field) => field.name === token.field)) !== null && _a !== void 0 ? _a : left.oneofs.find((oneof) => oneof.name === token.field)); + if (!right) { + throw err(`Unknown field "${token.field}"`, i); + } + } + else if ("ext" in token) { + right = (_b = options === null || options === void 0 ? void 0 : options.registry) === null || _b === void 0 ? void 0 : _b.getExtension(token.ext); + if (!right) { + throw err(`Unknown extension "${token.ext}"`, i); + } + } + else if ("val" in token) { + // list or map + right = + (left === null || left === void 0 ? void 0 : left.kind) == "field" && + left.fieldKind == "list" && + typeof token.val == "bigint" + ? { kind: "list_sub", index: Number(token.val) } + : { kind: "map_sub", key: token.val }; + } + else if ("err" in token) { + throw err(token.err, token.i); + } + if (right) { + try { + builder.add([right]); + } + catch (e) { + throw err(e instanceof InvalidPathError ? e.message : String(e), i); + } + } + i = token.i; + } + return builder.toPath(); +} +/** + * Stringify a path. + */ +export function pathToString(path) { + const str = []; + for (const ele of path) { + switch (ele.kind) { + case "field": + case "oneof": + if (str.length > 0) { + str.push("."); + } + str.push(ele.name); + break; + case "extension": + str.push("[", ele.typeName, "]"); + break; + case "list_sub": + str.push("[", ele.index, "]"); + break; + case "map_sub": + if (typeof ele.key == "string") { + str.push('["', ele.key + .split("\\") + .join("\\\\") + .split('"') + .join('\\"') + .split("\r") + .join("\\r") + .split("\n") + .join("\\n"), '"]'); + } + else { + str.push("[", ele.key, "]"); + } + break; + } + } + return str.join(""); +} +/** + * InvalidPathError is thrown for invalid Paths, for example during parsing from + * a string, or when a new Path is built. + */ +export class InvalidPathError extends Error { + constructor(schema, message, path) { + super(message); + this.name = "InvalidPathError"; + this.schema = schema; + this.path = path; + // see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#example + Object.setPrototypeOf(this, new.target.prototype); + } +} +class PathBuilderImpl { + constructor(schema, left, path) { + this.schema = schema; + this.left = left; + this.path = path; + } + getLeft() { + return this.left; + } + field(field) { + return this.push(field); + } + oneof(oneof) { + return this.push(oneof); + } + extension(extension) { + return this.push(extension); + } + list(index) { + return this.push({ kind: "list_sub", index }); + } + map(key) { + return this.push({ kind: "map_sub", key }); + } + add(pathOrBuilder) { + const path = Array.isArray(pathOrBuilder) + ? pathOrBuilder + : pathOrBuilder.toPath(); + const l = this.path.length; + try { + for (const ele of path) { + this.push(ele); + } + } + catch (e) { + // undo pushes + this.path.splice(l); + throw e; + } + return this; + } + toPath() { + return this.path.concat(); + } + clone() { + return new PathBuilderImpl(this.schema, this.left, this.path.concat()); + } + push(ele) { + switch (ele.kind) { + case "field": + if (!this.left || + this.left.kind != "message" || + this.left.typeName != ele.parent.typeName) { + throw this.err("field access"); + } + this.path.push(ele); + this.left = + ele.fieldKind == "message" + ? ele.message + : ele.fieldKind == "list" || ele.fieldKind == "map" + ? ele + : undefined; + return this; + case "oneof": + if (!this.left || + this.left.kind != "message" || + this.left.typeName != ele.parent.typeName) { + throw this.err("oneof access"); + } + this.path.push(ele); + this.left = undefined; + return this; + case "extension": + if (!this.left || + this.left.kind != "message" || + this.left.typeName != ele.extendee.typeName) { + throw this.err("extension access"); + } + this.path.push(ele); + this.left = ele.fieldKind == "message" ? ele.message : undefined; + return this; + case "list_sub": + if (!this.left || + this.left.kind != "field" || + this.left.fieldKind != "list") { + throw this.err("list access"); + } + if (ele.index < 0 || !Number.isInteger(ele.index)) { + throw this.err("list index"); + } + this.path.push(ele); + this.left = + this.left.listKind == "message" ? this.left.message : undefined; + return this; + case "map_sub": + if (!this.left || + this.left.kind != "field" || + this.left.fieldKind != "map") { + throw this.err("map access"); + } + if (!checkKeyType(ele.key, this.left.mapKey)) { + throw this.err("map key"); + } + this.path.push(ele); + this.left = + this.left.mapKind == "message" ? this.left.message : undefined; + return this; + } + } + err(what) { + return new InvalidPathError(this.schema, "Invalid " + what, this.path); + } +} +function checkKeyType(key, type) { + switch (type) { + case ScalarType.STRING: + return typeof key == "string"; + case ScalarType.INT32: + case ScalarType.UINT32: + case ScalarType.SINT32: + case ScalarType.SFIXED32: + case ScalarType.FIXED32: + return typeof key == "number"; + case ScalarType.UINT64: + case ScalarType.INT64: + case ScalarType.FIXED64: + case ScalarType.SFIXED64: + case ScalarType.SINT64: + return typeof key == "bigint"; + case ScalarType.BOOL: + return typeof key == "boolean"; + } +} +function nextToken(i, path) { + const re_extension = /^[A-Za-z_][A-Za-z_0-9]*(?:\.[A-Za-z_][A-Za-z_0-9]*)*$/; + const re_field = /^[A-Za-z_][A-Za-z_0-9]*$/; + if (path[i] == "[") { + i++; + while (path[i] == " ") { + // skip leading whitespace + i++; + } + if (i >= path.length) { + return { err: "Premature end", i: path.length - 1 }; + } + let token; + if (path[i] == `"`) { + // string literal + i++; + let val = ""; + for (;;) { + if (path[i] == `"`) { + // end of string literal + i++; + break; + } + if (path[i] == "\\") { + switch (path[i + 1]) { + case `"`: + case "\\": + val += path[i + 1]; + break; + case "r": + val += "\r"; + break; + case "n": + val += "\n"; + break; + default: + return { err: "Invalid escape sequence", i }; + } + i++; + } + else { + val += path[i]; + } + if (i >= path.length) { + return { err: "Premature end of string", i: path.length - 1 }; + } + i++; + } + token = { val }; + } + else if (path[i].match(/\d/)) { + // integer literal + const start = i; + while (i < path.length && /\d/.test(path[i])) { + i++; + } + token = { val: BigInt(path.substring(start, i)) }; + } + else if (path[i] == "]") { + return { err: "Premature ]", i }; + } + else { + // extension identifier or bool literal + const start = i; + while (i < path.length && path[i] != " " && path[i] != "]") { + i++; + } + const name = path.substring(start, i); + if (name === "true") { + token = { val: true }; + } + else if (name === "false") { + token = { val: false }; + } + else if (re_extension.test(name)) { + token = { ext: name }; + } + else { + return { err: "Invalid ident", i: start }; + } + } + while (path[i] == " ") { + // skip trailing whitespace + i++; + } + if (path[i] != "]") { + return { err: "Missing ]", i }; + } + i++; + return Object.assign(Object.assign({}, token), { i }); + } + // field identifier + if (i > 0) { + if (path[i] != ".") { + return { err: `Expected "."`, i }; + } + i++; + } + const start = i; + while (i < path.length && path[i] != "." && path[i] != "[") { + i++; + } + const field = path.substring(start, i); + return re_field.test(field) + ? { field, i } + : { err: "Invalid ident", i: start }; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-check.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-check.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..63f27b9e9befaa9d9e0e67d2aaeefde0843f2173 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-check.d.ts @@ -0,0 +1,19 @@ +import { type DescField } from "../descriptors.js"; +import { FieldError } from "./error.js"; +/** + * Check whether the given field value is valid for the reflect API. + */ +export declare function checkField(field: DescField, value: unknown): FieldError | undefined; +/** + * Check whether the given list item is valid for the reflect API. + */ +export declare function checkListItem(field: DescField & { + fieldKind: "list"; +}, index: number, value: unknown): FieldError | undefined; +/** + * Check whether the given map key and value are valid for the reflect API. + */ +export declare function checkMapEntry(field: DescField & { + fieldKind: "map"; +}, key: unknown, value: unknown): FieldError | undefined; +export declare function formatVal(val: unknown): string; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-check.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-check.js new file mode 100644 index 0000000000000000000000000000000000000000..3e938849c20faa57454e26d16b57807ccf372707 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-check.js @@ -0,0 +1,260 @@ +// Copyright 2021-2025 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. +import { ScalarType, } from "../descriptors.js"; +import { isMessage } from "../is-message.js"; +import { FieldError } from "./error.js"; +import { isReflectList, isReflectMap, isReflectMessage } from "./guard.js"; +import { FLOAT32_MAX, FLOAT32_MIN, INT32_MAX, INT32_MIN, UINT32_MAX, } from "../wire/binary-encoding.js"; +import { getTextEncoding } from "../wire/text-encoding.js"; +import { protoInt64 } from "../proto-int64.js"; +/** + * Check whether the given field value is valid for the reflect API. + */ +export function checkField(field, value) { + const check = field.fieldKind == "list" + ? isReflectList(value, field) + : field.fieldKind == "map" + ? isReflectMap(value, field) + : checkSingular(field, value); + if (check === true) { + return undefined; + } + let reason; + switch (field.fieldKind) { + case "list": + reason = `expected ${formatReflectList(field)}, got ${formatVal(value)}`; + break; + case "map": + reason = `expected ${formatReflectMap(field)}, got ${formatVal(value)}`; + break; + default: { + reason = reasonSingular(field, value, check); + } + } + return new FieldError(field, reason); +} +/** + * Check whether the given list item is valid for the reflect API. + */ +export function checkListItem(field, index, value) { + const check = checkSingular(field, value); + if (check !== true) { + return new FieldError(field, `list item #${index + 1}: ${reasonSingular(field, value, check)}`); + } + return undefined; +} +/** + * Check whether the given map key and value are valid for the reflect API. + */ +export function checkMapEntry(field, key, value) { + const checkKey = checkScalarValue(key, field.mapKey); + if (checkKey !== true) { + return new FieldError(field, `invalid map key: ${reasonSingular({ scalar: field.mapKey }, key, checkKey)}`); + } + const checkVal = checkSingular(field, value); + if (checkVal !== true) { + return new FieldError(field, `map entry ${formatVal(key)}: ${reasonSingular(field, value, checkVal)}`); + } + return undefined; +} +function checkSingular(field, value) { + if (field.scalar !== undefined) { + return checkScalarValue(value, field.scalar); + } + if (field.enum !== undefined) { + if (field.enum.open) { + return Number.isInteger(value); + } + return field.enum.values.some((v) => v.number === value); + } + return isReflectMessage(value, field.message); +} +function checkScalarValue(value, scalar) { + switch (scalar) { + case ScalarType.DOUBLE: + return typeof value == "number"; + case ScalarType.FLOAT: + if (typeof value != "number") { + return false; + } + if (Number.isNaN(value) || !Number.isFinite(value)) { + return true; + } + if (value > FLOAT32_MAX || value < FLOAT32_MIN) { + return `${value.toFixed()} out of range`; + } + return true; + case ScalarType.INT32: + case ScalarType.SFIXED32: + case ScalarType.SINT32: + // signed + if (typeof value !== "number" || !Number.isInteger(value)) { + return false; + } + if (value > INT32_MAX || value < INT32_MIN) { + return `${value.toFixed()} out of range`; + } + return true; + case ScalarType.FIXED32: + case ScalarType.UINT32: + // unsigned + if (typeof value !== "number" || !Number.isInteger(value)) { + return false; + } + if (value > UINT32_MAX || value < 0) { + return `${value.toFixed()} out of range`; + } + return true; + case ScalarType.BOOL: + return typeof value == "boolean"; + case ScalarType.STRING: + if (typeof value != "string") { + return false; + } + return getTextEncoding().checkUtf8(value) || "invalid UTF8"; + case ScalarType.BYTES: + return value instanceof Uint8Array; + case ScalarType.INT64: + case ScalarType.SFIXED64: + case ScalarType.SINT64: + // signed + if (typeof value == "bigint" || + typeof value == "number" || + (typeof value == "string" && value.length > 0)) { + try { + protoInt64.parse(value); + return true; + } + catch (_) { + return `${value} out of range`; + } + } + return false; + case ScalarType.FIXED64: + case ScalarType.UINT64: + // unsigned + if (typeof value == "bigint" || + typeof value == "number" || + (typeof value == "string" && value.length > 0)) { + try { + protoInt64.uParse(value); + return true; + } + catch (_) { + return `${value} out of range`; + } + } + return false; + } +} +function reasonSingular(field, val, details) { + details = + typeof details == "string" ? `: ${details}` : `, got ${formatVal(val)}`; + if (field.scalar !== undefined) { + return `expected ${scalarTypeDescription(field.scalar)}` + details; + } + if (field.enum !== undefined) { + return `expected ${field.enum.toString()}` + details; + } + return `expected ${formatReflectMessage(field.message)}` + details; +} +export function formatVal(val) { + switch (typeof val) { + case "object": + if (val === null) { + return "null"; + } + if (val instanceof Uint8Array) { + return `Uint8Array(${val.length})`; + } + if (Array.isArray(val)) { + return `Array(${val.length})`; + } + if (isReflectList(val)) { + return formatReflectList(val.field()); + } + if (isReflectMap(val)) { + return formatReflectMap(val.field()); + } + if (isReflectMessage(val)) { + return formatReflectMessage(val.desc); + } + if (isMessage(val)) { + return `message ${val.$typeName}`; + } + return "object"; + case "string": + return val.length > 30 ? "string" : `"${val.split('"').join('\\"')}"`; + case "boolean": + return String(val); + case "number": + return String(val); + case "bigint": + return String(val) + "n"; + default: + // "symbol" | "undefined" | "object" | "function" + return typeof val; + } +} +function formatReflectMessage(desc) { + return `ReflectMessage (${desc.typeName})`; +} +function formatReflectList(field) { + switch (field.listKind) { + case "message": + return `ReflectList (${field.message.toString()})`; + case "enum": + return `ReflectList (${field.enum.toString()})`; + case "scalar": + return `ReflectList (${ScalarType[field.scalar]})`; + } +} +function formatReflectMap(field) { + switch (field.mapKind) { + case "message": + return `ReflectMap (${ScalarType[field.mapKey]}, ${field.message.toString()})`; + case "enum": + return `ReflectMap (${ScalarType[field.mapKey]}, ${field.enum.toString()})`; + case "scalar": + return `ReflectMap (${ScalarType[field.mapKey]}, ${ScalarType[field.scalar]})`; + } +} +function scalarTypeDescription(scalar) { + switch (scalar) { + case ScalarType.STRING: + return "string"; + case ScalarType.BOOL: + return "boolean"; + case ScalarType.INT64: + case ScalarType.SINT64: + case ScalarType.SFIXED64: + return "bigint (int64)"; + case ScalarType.UINT64: + case ScalarType.FIXED64: + return "bigint (uint64)"; + case ScalarType.BYTES: + return "Uint8Array"; + case ScalarType.DOUBLE: + return "number (float64)"; + case ScalarType.FLOAT: + return "number (float32)"; + case ScalarType.FIXED32: + case ScalarType.UINT32: + return "number (uint32)"; + case ScalarType.INT32: + case ScalarType.SFIXED32: + case ScalarType.SINT32: + return "number (int32)"; + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-types.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-types.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f300dd9e2d48f6928ec786f5eaa24d31c011a37b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-types.d.ts @@ -0,0 +1,217 @@ +import type { DescField, DescMessage, DescOneof } from "../descriptors.js"; +import { unsafeLocal } from "./unsafe.js"; +import type { Message, UnknownField } from "../types.js"; +import type { ScalarValue } from "./scalar.js"; +/** + * ReflectMessage provides dynamic access and manipulation of a message. + */ +export interface ReflectMessage { + /** + * The underlying message instance. + */ + readonly message: Message; + /** + * The descriptor for the message. + */ + readonly desc: DescMessage; + /** + * The fields of the message. This is a shortcut to message.fields. + */ + readonly fields: readonly DescField[]; + /** + * The fields of the message, sorted by field number ascending. + */ + readonly sortedFields: readonly DescField[]; + /** + * Oneof groups of the message. This is a shortcut to message.oneofs. + */ + readonly oneofs: readonly DescOneof[]; + /** + * Fields and oneof groups for this message. This is a shortcut to message.members. + */ + readonly members: readonly (DescField | DescOneof)[]; + /** + * Find a field by number. + */ + findNumber(number: number): DescField | undefined; + /** + * Returns true if the field is set. + * + * - Scalar and enum fields with implicit presence (proto3): + * Set if not a zero value. + * + * - Scalar and enum fields with explicit presence (proto2, oneof): + * Set if a value was set when creating or parsing the message, or when a + * value was assigned to the field's property. + * + * - Message fields: + * Set if the property is not undefined. + * + * - List and map fields: + * Set if not empty. + */ + isSet(field: DescField): boolean; + /** + * Resets the field, so that isSet() will return false. + */ + clear(field: DescField): void; + /** + * Return the selected field of a oneof group. + */ + oneofCase(oneof: DescOneof): DescField | undefined; + /** + * Returns the field value. Values are converted or wrapped to make it easier + * to manipulate messages. + * + * - Scalar fields: + * Returns the value, but converts 64-bit integer fields with the option + * `jstype=JS_STRING` to a bigint value. + * If the field is not set, the default value is returned. If no default + * value is set, the zero value is returned. + * + * - Enum fields: + * Returns the numeric value. If the field is not set, the default value is + * returned. If no default value is set, the zero value is returned. + * + * - Message fields: + * Returns a ReflectMessage. If the field is not set, a new message is + * returned, but not set on the field. + * + * - List fields: + * Returns a ReflectList object. + * + * - Map fields: + * Returns a ReflectMap object. + * + * Note that get() never returns `undefined`. To determine whether a field is + * set, use isSet(). + */ + get(field: Field): ReflectMessageGet; + /** + * Set a field value. + * + * Expects values in the same form that get() returns: + * + * - Scalar fields: + * 64-bit integer fields with the option `jstype=JS_STRING` as a bigint value. + * + * - Message fields: + * ReflectMessage. + * + * - List fields: + * ReflectList. + * + * - Map fields: + * ReflectMap. + * + * Throws an error if the value is invalid for the field. `undefined` is not + * a valid value. To reset a field, use clear(). + */ + set(field: Field, value: unknown): void; + /** + * Returns the unknown fields of the message. + */ + getUnknown(): UnknownField[] | undefined; + /** + * Sets the unknown fields of the message, overwriting any previous values. + */ + setUnknown(value: UnknownField[]): void; + [unsafeLocal]: Message; +} +/** + * ReflectList provides dynamic access and manipulation of a list field on a + * message. + * + * ReflectList is iterable - you can loop through all items with a for...of loop. + * + * Values are converted or wrapped to make it easier to manipulate them: + * - Scalar 64-bit integer fields with the option `jstype=JS_STRING` are + * converted to bigint. + * - Messages are wrapped in a ReflectMessage. + */ +export interface ReflectList extends Iterable { + /** + * Returns the list field. + */ + field(): DescField & { + fieldKind: "list"; + }; + /** + * The size of the list. + */ + readonly size: number; + /** + * Retrieves the item at the specified index, or undefined if the index + * is out of range. + */ + get(index: number): V | undefined; + /** + * Adds an item at the end of the list. + * Throws an error if an item is invalid for this list. + */ + add(item: V): void; + /** + * Replaces the item at the specified index with the specified item. + * Throws an error if the index is out of range (index < 0 || index >= size). + * Throws an error if the item is invalid for this list. + */ + set(index: number, item: V): void; + /** + * Removes all items from the list. + */ + clear(): void; + [Symbol.iterator](): IterableIterator; + entries(): IterableIterator<[number, V]>; + keys(): IterableIterator; + values(): IterableIterator; + [unsafeLocal]: unknown[]; +} +/** + * ReflectMap provides dynamic access and manipulation of a map field on a + * message. + * + * ReflectMap is iterable - you can loop through all entries with a for...of loop. + * + * Keys and values are converted or wrapped to make it easier to manipulate them: + * - A map field is a record object on a message, where keys are always strings. + * ReflectMap converts keys to their closest possible type in TypeScript. + * - Messages are wrapped in a ReflectMessage. + */ +export interface ReflectMap extends ReadonlyMap { + /** + * Returns the map field. + */ + field(): DescField & { + fieldKind: "map"; + }; + /** + * Removes the entry for the specified key. + * Returns false if the key is unknown. + */ + delete(key: K): boolean; + /** + * Sets or replaces the item at the specified key with the specified value. + * Throws an error if the key or value is invalid for this map. + */ + set(key: K, value: V): this; + /** + * Removes all entries from the map. + */ + clear(): void; + [unsafeLocal]: Record; +} +/** + * The return type of ReflectMessage.get() + */ +export type ReflectMessageGet = (Field extends { + fieldKind: "map"; +} ? ReflectMap : Field extends { + fieldKind: "list"; +} ? ReflectList : Field extends { + fieldKind: "enum"; +} ? number : Field extends { + fieldKind: "message"; +} ? ReflectMessage : Field extends { + fieldKind: "scalar"; + scalar: infer T; +} ? ScalarValue : never); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-types.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-types.js new file mode 100644 index 0000000000000000000000000000000000000000..f653c026b4df099b1404b31d14d03cb0a9b460e6 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect-types.js @@ -0,0 +1,14 @@ +// Copyright 2021-2025 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. +import { unsafeLocal } from "./unsafe.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3bfb1adbb2e7f2488cc3e5acbb54d9da48291f10 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect.d.ts @@ -0,0 +1,43 @@ +import { type DescField, type DescMessage } from "../descriptors.js"; +import type { MessageShape } from "../types.js"; +import type { ReflectList, ReflectMap, ReflectMessage } from "./reflect-types.js"; +/** + * Create a ReflectMessage. + */ +export declare function reflect(messageDesc: Desc, message?: MessageShape, +/** + * By default, field values are validated when setting them. For example, + * a value for an uint32 field must be a ECMAScript Number >= 0. + * + * When field values are trusted, performance can be improved by disabling + * checks. + */ +check?: boolean): ReflectMessage; +/** + * Create a ReflectList. + */ +export declare function reflectList(field: DescField & { + fieldKind: "list"; +}, unsafeInput?: unknown[], +/** + * By default, field values are validated when setting them. For example, + * a value for an uint32 field must be a ECMAScript Number >= 0. + * + * When field values are trusted, performance can be improved by disabling + * checks. + */ +check?: boolean): ReflectList; +/** + * Create a ReflectMap. + */ +export declare function reflectMap(field: DescField & { + fieldKind: "map"; +}, unsafeInput?: Record, +/** + * By default, field values are validated when setting them. For example, + * a value for an uint32 field must be a ECMAScript Number >= 0. + * + * When field values are trusted, performance can be improved by disabling + * checks. + */ +check?: boolean): ReflectMap; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect.js new file mode 100644 index 0000000000000000000000000000000000000000..82e5f01b806971ba91971b2a7fd8826b284d54e7 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/reflect.js @@ -0,0 +1,536 @@ +// Copyright 2021-2025 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. +import { ScalarType, } from "../descriptors.js"; +import { checkField, checkListItem, checkMapEntry } from "./reflect-check.js"; +import { FieldError } from "./error.js"; +import { unsafeClear, unsafeGet, unsafeIsSet, unsafeLocal, unsafeOneofCase, unsafeSet, } from "./unsafe.js"; +import { create } from "../create.js"; +import { isWrapper, isWrapperDesc } from "../wkt/wrappers.js"; +import { scalarZeroValue } from "./scalar.js"; +import { protoInt64 } from "../proto-int64.js"; +import { isObject, isReflectList, isReflectMap, isReflectMessage, } from "./guard.js"; +/** + * Create a ReflectMessage. + */ +export function reflect(messageDesc, message, +/** + * By default, field values are validated when setting them. For example, + * a value for an uint32 field must be a ECMAScript Number >= 0. + * + * When field values are trusted, performance can be improved by disabling + * checks. + */ +check = true) { + return new ReflectMessageImpl(messageDesc, message, check); +} +class ReflectMessageImpl { + get sortedFields() { + var _a; + return ((_a = this._sortedFields) !== null && _a !== void 0 ? _a : + // biome-ignore lint/suspicious/noAssignInExpressions: no + (this._sortedFields = this.desc.fields + .concat() + .sort((a, b) => a.number - b.number))); + } + constructor(messageDesc, message, check = true) { + this.lists = new Map(); + this.maps = new Map(); + this.check = check; + this.desc = messageDesc; + this.message = this[unsafeLocal] = message !== null && message !== void 0 ? message : create(messageDesc); + this.fields = messageDesc.fields; + this.oneofs = messageDesc.oneofs; + this.members = messageDesc.members; + } + findNumber(number) { + if (!this._fieldsByNumber) { + this._fieldsByNumber = new Map(this.desc.fields.map((f) => [f.number, f])); + } + return this._fieldsByNumber.get(number); + } + oneofCase(oneof) { + assertOwn(this.message, oneof); + return unsafeOneofCase(this.message, oneof); + } + isSet(field) { + assertOwn(this.message, field); + return unsafeIsSet(this.message, field); + } + clear(field) { + assertOwn(this.message, field); + unsafeClear(this.message, field); + } + get(field) { + assertOwn(this.message, field); + const value = unsafeGet(this.message, field); + switch (field.fieldKind) { + case "list": + // eslint-disable-next-line no-case-declarations + let list = this.lists.get(field); + if (!list || list[unsafeLocal] !== value) { + this.lists.set(field, + // biome-ignore lint/suspicious/noAssignInExpressions: no + (list = new ReflectListImpl(field, value, this.check))); + } + return list; + case "map": + let map = this.maps.get(field); + if (!map || map[unsafeLocal] !== value) { + this.maps.set(field, + // biome-ignore lint/suspicious/noAssignInExpressions: no + (map = new ReflectMapImpl(field, value, this.check))); + } + return map; + case "message": + return messageToReflect(field, value, this.check); + case "scalar": + return (value === undefined + ? scalarZeroValue(field.scalar, false) + : longToReflect(field, value)); + case "enum": + return (value !== null && value !== void 0 ? value : field.enum.values[0].number); + } + } + set(field, value) { + assertOwn(this.message, field); + if (this.check) { + const err = checkField(field, value); + if (err) { + throw err; + } + } + let local; + if (field.fieldKind == "message") { + local = messageToLocal(field, value); + } + else if (isReflectMap(value) || isReflectList(value)) { + local = value[unsafeLocal]; + } + else { + local = longToLocal(field, value); + } + unsafeSet(this.message, field, local); + } + getUnknown() { + return this.message.$unknown; + } + setUnknown(value) { + this.message.$unknown = value; + } +} +function assertOwn(owner, member) { + if (member.parent.typeName !== owner.$typeName) { + throw new FieldError(member, `cannot use ${member.toString()} with message ${owner.$typeName}`, "ForeignFieldError"); + } +} +/** + * Create a ReflectList. + */ +export function reflectList(field, unsafeInput, +/** + * By default, field values are validated when setting them. For example, + * a value for an uint32 field must be a ECMAScript Number >= 0. + * + * When field values are trusted, performance can be improved by disabling + * checks. + */ +check = true) { + return new ReflectListImpl(field, unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : [], check); +} +class ReflectListImpl { + field() { + return this._field; + } + get size() { + return this._arr.length; + } + constructor(field, unsafeInput, check) { + this._field = field; + this._arr = this[unsafeLocal] = unsafeInput; + this.check = check; + } + get(index) { + const item = this._arr[index]; + return item === undefined + ? undefined + : listItemToReflect(this._field, item, this.check); + } + set(index, item) { + if (index < 0 || index >= this._arr.length) { + throw new FieldError(this._field, `list item #${index + 1}: out of range`); + } + if (this.check) { + const err = checkListItem(this._field, index, item); + if (err) { + throw err; + } + } + this._arr[index] = listItemToLocal(this._field, item); + } + add(item) { + if (this.check) { + const err = checkListItem(this._field, this._arr.length, item); + if (err) { + throw err; + } + } + this._arr.push(listItemToLocal(this._field, item)); + return undefined; + } + clear() { + this._arr.splice(0, this._arr.length); + } + [Symbol.iterator]() { + return this.values(); + } + keys() { + return this._arr.keys(); + } + *values() { + for (const item of this._arr) { + yield listItemToReflect(this._field, item, this.check); + } + } + *entries() { + for (let i = 0; i < this._arr.length; i++) { + yield [i, listItemToReflect(this._field, this._arr[i], this.check)]; + } + } +} +/** + * Create a ReflectMap. + */ +export function reflectMap(field, unsafeInput, +/** + * By default, field values are validated when setting them. For example, + * a value for an uint32 field must be a ECMAScript Number >= 0. + * + * When field values are trusted, performance can be improved by disabling + * checks. + */ +check = true) { + return new ReflectMapImpl(field, unsafeInput, check); +} +class ReflectMapImpl { + constructor(field, unsafeInput, check = true) { + this.obj = this[unsafeLocal] = unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : {}; + this.check = check; + this._field = field; + } + field() { + return this._field; + } + set(key, value) { + if (this.check) { + const err = checkMapEntry(this._field, key, value); + if (err) { + throw err; + } + } + this.obj[mapKeyToLocal(key)] = mapValueToLocal(this._field, value); + return this; + } + delete(key) { + const k = mapKeyToLocal(key); + const has = Object.prototype.hasOwnProperty.call(this.obj, k); + if (has) { + delete this.obj[k]; + } + return has; + } + clear() { + for (const key of Object.keys(this.obj)) { + delete this.obj[key]; + } + } + get(key) { + let val = this.obj[mapKeyToLocal(key)]; + if (val !== undefined) { + val = mapValueToReflect(this._field, val, this.check); + } + return val; + } + has(key) { + return Object.prototype.hasOwnProperty.call(this.obj, mapKeyToLocal(key)); + } + *keys() { + for (const objKey of Object.keys(this.obj)) { + yield mapKeyToReflect(objKey, this._field.mapKey); + } + } + *entries() { + for (const objEntry of Object.entries(this.obj)) { + yield [ + mapKeyToReflect(objEntry[0], this._field.mapKey), + mapValueToReflect(this._field, objEntry[1], this.check), + ]; + } + } + [Symbol.iterator]() { + return this.entries(); + } + get size() { + return Object.keys(this.obj).length; + } + *values() { + for (const val of Object.values(this.obj)) { + yield mapValueToReflect(this._field, val, this.check); + } + } + forEach(callbackfn, thisArg) { + for (const mapEntry of this.entries()) { + callbackfn.call(thisArg, mapEntry[1], mapEntry[0], this); + } + } +} +function messageToLocal(field, value) { + if (!isReflectMessage(value)) { + return value; + } + if (isWrapper(value.message) && + !field.oneof && + field.fieldKind == "message") { + // Types from google/protobuf/wrappers.proto are unwrapped when used in + // a singular field that is not part of a oneof group. + return value.message.value; + } + if (value.desc.typeName == "google.protobuf.Struct" && + field.parent.typeName != "google.protobuf.Value") { + // google.protobuf.Struct is represented with JsonObject when used in a + // field, except when used in google.protobuf.Value. + return wktStructToLocal(value.message); + } + return value.message; +} +function messageToReflect(field, value, check) { + if (value !== undefined) { + if (isWrapperDesc(field.message) && + !field.oneof && + field.fieldKind == "message") { + // Types from google/protobuf/wrappers.proto are unwrapped when used in + // a singular field that is not part of a oneof group. + value = { + $typeName: field.message.typeName, + value: longToReflect(field.message.fields[0], value), + }; + } + else if (field.message.typeName == "google.protobuf.Struct" && + field.parent.typeName != "google.protobuf.Value" && + isObject(value)) { + // google.protobuf.Struct is represented with JsonObject when used in a + // field, except when used in google.protobuf.Value. + value = wktStructToReflect(value); + } + } + return new ReflectMessageImpl(field.message, value, check); +} +function listItemToLocal(field, value) { + if (field.listKind == "message") { + return messageToLocal(field, value); + } + return longToLocal(field, value); +} +function listItemToReflect(field, value, check) { + if (field.listKind == "message") { + return messageToReflect(field, value, check); + } + return longToReflect(field, value); +} +function mapValueToLocal(field, value) { + if (field.mapKind == "message") { + return messageToLocal(field, value); + } + return longToLocal(field, value); +} +function mapValueToReflect(field, value, check) { + if (field.mapKind == "message") { + return messageToReflect(field, value, check); + } + return value; +} +function mapKeyToLocal(key) { + return typeof key == "string" || typeof key == "number" ? key : String(key); +} +/** + * Converts a map key (any scalar value except float, double, or bytes) from its + * representation in a message (string or number, the only possible object key + * types) to the closest possible type in ECMAScript. + */ +function mapKeyToReflect(key, type) { + switch (type) { + case ScalarType.STRING: + return key; + case ScalarType.INT32: + case ScalarType.FIXED32: + case ScalarType.UINT32: + case ScalarType.SFIXED32: + case ScalarType.SINT32: { + const n = Number.parseInt(key); + if (Number.isFinite(n)) { + return n; + } + break; + } + case ScalarType.BOOL: + switch (key) { + case "true": + return true; + case "false": + return false; + } + break; + case ScalarType.UINT64: + case ScalarType.FIXED64: + try { + return protoInt64.uParse(key); + } + catch (_a) { + // + } + break; + default: + // INT64, SFIXED64, SINT64 + try { + return protoInt64.parse(key); + } + catch (_b) { + // + } + break; + } + return key; +} +function longToReflect(field, value) { + switch (field.scalar) { + case ScalarType.INT64: + case ScalarType.SFIXED64: + case ScalarType.SINT64: + if ("longAsString" in field && + field.longAsString && + typeof value == "string") { + value = protoInt64.parse(value); + } + break; + case ScalarType.FIXED64: + case ScalarType.UINT64: + if ("longAsString" in field && + field.longAsString && + typeof value == "string") { + value = protoInt64.uParse(value); + } + break; + } + return value; +} +function longToLocal(field, value) { + switch (field.scalar) { + case ScalarType.INT64: + case ScalarType.SFIXED64: + case ScalarType.SINT64: + if ("longAsString" in field && field.longAsString) { + value = String(value); + } + else if (typeof value == "string" || typeof value == "number") { + value = protoInt64.parse(value); + } + break; + case ScalarType.FIXED64: + case ScalarType.UINT64: + if ("longAsString" in field && field.longAsString) { + value = String(value); + } + else if (typeof value == "string" || typeof value == "number") { + value = protoInt64.uParse(value); + } + break; + } + return value; +} +function wktStructToReflect(json) { + const struct = { + $typeName: "google.protobuf.Struct", + fields: {}, + }; + if (isObject(json)) { + for (const [k, v] of Object.entries(json)) { + struct.fields[k] = wktValueToReflect(v); + } + } + return struct; +} +function wktStructToLocal(val) { + const json = {}; + for (const [k, v] of Object.entries(val.fields)) { + json[k] = wktValueToLocal(v); + } + return json; +} +function wktValueToLocal(val) { + switch (val.kind.case) { + case "structValue": + return wktStructToLocal(val.kind.value); + case "listValue": + return val.kind.value.values.map(wktValueToLocal); + case "nullValue": + case undefined: + return null; + default: + return val.kind.value; + } +} +function wktValueToReflect(json) { + const value = { + $typeName: "google.protobuf.Value", + kind: { case: undefined }, + }; + switch (typeof json) { + case "number": + value.kind = { case: "numberValue", value: json }; + break; + case "string": + value.kind = { case: "stringValue", value: json }; + break; + case "boolean": + value.kind = { case: "boolValue", value: json }; + break; + case "object": + if (json === null) { + const nullValue = 0; + value.kind = { case: "nullValue", value: nullValue }; + } + else if (Array.isArray(json)) { + const listValue = { + $typeName: "google.protobuf.ListValue", + values: [], + }; + if (Array.isArray(json)) { + for (const e of json) { + listValue.values.push(wktValueToReflect(e)); + } + } + value.kind = { + case: "listValue", + value: listValue, + }; + } + else { + value.kind = { + case: "structValue", + value: wktStructToReflect(json), + }; + } + break; + } + return value; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/scalar.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/scalar.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..16ac91fe34d86972ada05033b9728b60a724df17 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/scalar.d.ts @@ -0,0 +1,21 @@ +import { ScalarType } from "../descriptors.js"; +/** + * ScalarValue maps from a scalar field type to a TypeScript value type. + */ +export type ScalarValue = T extends ScalarType.STRING ? string : T extends ScalarType.INT32 ? number : T extends ScalarType.UINT32 ? number : T extends ScalarType.SINT32 ? number : T extends ScalarType.FIXED32 ? number : T extends ScalarType.SFIXED32 ? number : T extends ScalarType.FLOAT ? number : T extends ScalarType.DOUBLE ? number : T extends ScalarType.INT64 ? LongAsString extends true ? string : bigint : T extends ScalarType.SINT64 ? LongAsString extends true ? string : bigint : T extends ScalarType.SFIXED64 ? LongAsString extends true ? string : bigint : T extends ScalarType.UINT64 ? LongAsString extends true ? string : bigint : T extends ScalarType.FIXED64 ? LongAsString extends true ? string : bigint : T extends ScalarType.BOOL ? boolean : T extends ScalarType.BYTES ? Uint8Array : never; +/** + * Returns true if both scalar values are equal. + */ +export declare function scalarEquals(type: ScalarType, a: ScalarValue | undefined, b: ScalarValue | undefined): boolean; +/** + * Returns the zero value for the given scalar type. + */ +export declare function scalarZeroValue(type: T, longAsString: LongAsString): ScalarValue; +/** + * Returns true for a zero-value. For example, an integer has the zero-value `0`, + * a boolean is `false`, a string is `""`, and bytes is an empty Uint8Array. + * + * In proto3, zero-values are not written to the wire, unless the field is + * optional or repeated. + */ +export declare function isScalarZeroValue(type: ScalarType, value: unknown): boolean; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/scalar.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/scalar.js new file mode 100644 index 0000000000000000000000000000000000000000..c7bf82e244bafeb96a8a141295e7bd9235db00a3 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/scalar.js @@ -0,0 +1,97 @@ +// Copyright 2021-2025 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. +import { protoInt64 } from "../proto-int64.js"; +import { ScalarType } from "../descriptors.js"; +/** + * Returns true if both scalar values are equal. + */ +export function scalarEquals(type, a, b) { + if (a === b) { + // This correctly matches equal values except BYTES and (possibly) 64-bit integers. + return true; + } + // Special case BYTES - we need to compare each byte individually + if (type == ScalarType.BYTES) { + if (!(a instanceof Uint8Array) || !(b instanceof Uint8Array)) { + return false; + } + if (a.length !== b.length) { + return false; + } + for (let i = 0; i < a.length; i++) { + if (a[i] !== b[i]) { + return false; + } + } + return true; + } + // Special case 64-bit integers - we support number, string and bigint representation. + switch (type) { + case ScalarType.UINT64: + case ScalarType.FIXED64: + case ScalarType.INT64: + case ScalarType.SFIXED64: + case ScalarType.SINT64: + // Loose comparison will match between 0n, 0 and "0". + return a == b; + } + // Anything that hasn't been caught by strict comparison or special cased + // BYTES and 64-bit integers is not equal. + return false; +} +/** + * Returns the zero value for the given scalar type. + */ +export function scalarZeroValue(type, longAsString) { + switch (type) { + case ScalarType.STRING: + return ""; + case ScalarType.BOOL: + return false; + case ScalarType.DOUBLE: + case ScalarType.FLOAT: + return 0.0; + case ScalarType.INT64: + case ScalarType.UINT64: + case ScalarType.SFIXED64: + case ScalarType.FIXED64: + case ScalarType.SINT64: + return (longAsString ? "0" : protoInt64.zero); + case ScalarType.BYTES: + return new Uint8Array(0); + default: + // Handles INT32, UINT32, SINT32, FIXED32, SFIXED32. + // We do not use individual cases to save a few bytes code size. + return 0; + } +} +/** + * Returns true for a zero-value. For example, an integer has the zero-value `0`, + * a boolean is `false`, a string is `""`, and bytes is an empty Uint8Array. + * + * In proto3, zero-values are not written to the wire, unless the field is + * optional or repeated. + */ +export function isScalarZeroValue(type, value) { + switch (type) { + case ScalarType.BOOL: + return value === false; + case ScalarType.STRING: + return value === ""; + case ScalarType.BYTES: + return value instanceof Uint8Array && !value.byteLength; + default: + return value == 0; // Loose comparison matches 0n, 0 and "0" + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/unsafe.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/unsafe.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..02fd72f4a4cccde6a4c0711cdaf2ddc1ec72a063 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/unsafe.d.ts @@ -0,0 +1,39 @@ +import type { DescField, DescOneof } from "../descriptors.js"; +export declare const unsafeLocal: unique symbol; +/** + * Return the selected field of a oneof group. + * + * @private + */ +export declare function unsafeOneofCase(target: Record, oneof: DescOneof): DescField | undefined; +/** + * Returns true if the field is set. + * + * @private + */ +export declare function unsafeIsSet(target: Record, field: DescField): boolean; +/** + * Returns true if the field is set, but only for singular fields with explicit + * presence (proto2). + * + * @private + */ +export declare function unsafeIsSetExplicit(target: object, localName: string): boolean; +/** + * Return a field value, respecting oneof groups. + * + * @private + */ +export declare function unsafeGet(target: Record, field: DescField): unknown; +/** + * Set a field value, respecting oneof groups. + * + * @private + */ +export declare function unsafeSet(target: Record, field: DescField, value: unknown): void; +/** + * Resets the field, so that unsafeIsSet() will return false. + * + * @private + */ +export declare function unsafeClear(target: Record, field: DescField): void; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/unsafe.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/unsafe.js new file mode 100644 index 0000000000000000000000000000000000000000..55bcd7f5ceaac614855d2d070872d57f2c926bdd --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/reflect/unsafe.js @@ -0,0 +1,140 @@ +// Copyright 2021-2025 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. +import { isScalarZeroValue, scalarZeroValue } from "./scalar.js"; +// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number; +const IMPLICIT = 2; +export const unsafeLocal = Symbol.for("reflect unsafe local"); +/** + * Return the selected field of a oneof group. + * + * @private + */ +export function unsafeOneofCase( +// biome-ignore lint/suspicious/noExplicitAny: `any` is the best choice for dynamic access +target, oneof) { + const c = target[oneof.localName].case; + if (c === undefined) { + return c; + } + return oneof.fields.find((f) => f.localName === c); +} +/** + * Returns true if the field is set. + * + * @private + */ +export function unsafeIsSet( +// biome-ignore lint/suspicious/noExplicitAny: `any` is the best choice for dynamic access +target, field) { + const name = field.localName; + if (field.oneof) { + return target[field.oneof.localName].case === name; + } + if (field.presence != IMPLICIT) { + // Fields with explicit presence have properties on the prototype chain + // for default / zero values (except for proto3). + return (target[name] !== undefined && + Object.prototype.hasOwnProperty.call(target, name)); + } + switch (field.fieldKind) { + case "list": + return target[name].length > 0; + case "map": + return Object.keys(target[name]).length > 0; + case "scalar": + return !isScalarZeroValue(field.scalar, target[name]); + case "enum": + return target[name] !== field.enum.values[0].number; + } + throw new Error("message field with implicit presence"); +} +/** + * Returns true if the field is set, but only for singular fields with explicit + * presence (proto2). + * + * @private + */ +export function unsafeIsSetExplicit(target, localName) { + return (Object.prototype.hasOwnProperty.call(target, localName) && + target[localName] !== undefined); +} +/** + * Return a field value, respecting oneof groups. + * + * @private + */ +export function unsafeGet(target, field) { + if (field.oneof) { + const oneof = target[field.oneof.localName]; + if (oneof.case === field.localName) { + return oneof.value; + } + return undefined; + } + return target[field.localName]; +} +/** + * Set a field value, respecting oneof groups. + * + * @private + */ +export function unsafeSet(target, field, value) { + if (field.oneof) { + target[field.oneof.localName] = { + case: field.localName, + value: value, + }; + } + else { + target[field.localName] = value; + } +} +/** + * Resets the field, so that unsafeIsSet() will return false. + * + * @private + */ +export function unsafeClear( +// biome-ignore lint/suspicious/noExplicitAny: `any` is the best choice for dynamic access +target, field) { + const name = field.localName; + if (field.oneof) { + const oneofLocalName = field.oneof.localName; + if (target[oneofLocalName].case === name) { + target[oneofLocalName] = { case: undefined }; + } + } + else if (field.presence != IMPLICIT) { + // Fields with explicit presence have properties on the prototype chain + // for default / zero values (except for proto3). By deleting their own + // property, the field is reset. + delete target[name]; + } + else { + switch (field.fieldKind) { + case "map": + target[name] = {}; + break; + case "list": + target[name] = []; + break; + case "enum": + target[name] = field.enum.values[0].number; + break; + case "scalar": + target[name] = scalarZeroValue(field.scalar, field.longAsString); + break; + } + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/registry.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/registry.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4a1b5aedf1a5a8f626707a877a7d0008dce7f48a --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/registry.d.ts @@ -0,0 +1,98 @@ +import type { FileDescriptorProto, FileDescriptorSet } from "./wkt/gen/google/protobuf/descriptor_pb.js"; +import { type DescEnum, type DescExtension, type DescFile, type DescMessage, type DescService, type SupportedEdition } from "./descriptors.js"; +/** + * A set of descriptors for messages, enumerations, extensions, + * and services. + */ +export interface Registry { + readonly kind: "registry"; + /** + * All types (message, enumeration, extension, or service) contained + * in this registry. + */ + [Symbol.iterator](): IterableIterator; + /** + * Look up a type (message, enumeration, extension, or service) by + * its fully qualified name. + */ + get(typeName: string): DescMessage | DescEnum | DescExtension | DescService | undefined; + /** + * Look up a message descriptor by its fully qualified name. + */ + getMessage(typeName: string): DescMessage | undefined; + /** + * Look up an enumeration descriptor by its fully qualified name. + */ + getEnum(typeName: string): DescEnum | undefined; + /** + * Look up an extension descriptor by its fully qualified name. + */ + getExtension(typeName: string): DescExtension | undefined; + /** + * Look up an extension by the extendee - the message it extends - and + * the extension number. + */ + getExtensionFor(extendee: DescMessage, no: number): DescExtension | undefined; + /** + * Look up a service descriptor by its fully qualified name. + */ + getService(typeName: string): DescService | undefined; +} +/** + * A registry that allows adding and removing descriptors. + */ +export interface MutableRegistry extends Registry { + /** + * Adds the given descriptor - but not types nested within - to the registry. + */ + add(desc: DescMessage | DescEnum | DescExtension | DescService): void; + /** + * Remove the given descriptor - but not types nested within - from the registry. + */ + remove(desc: DescMessage | DescEnum | DescExtension | DescService): void; +} +/** + * A registry that includes files. + */ +export interface FileRegistry extends Registry { + /** + * All files in this registry. + */ + readonly files: Iterable; + /** + * Look up a file descriptor by file name. + */ + getFile(fileName: string): DescFile | undefined; +} +/** + * Create a registry from the given inputs. + * + * An input can be: + * - Any message, enum, service, or extension descriptor, which adds just the + * descriptor for this type. + * - A file descriptor, which adds all typed defined in this file. + * - A registry, which adds all types from the registry. + * + * For duplicate descriptors (same type name), the one given last wins. + */ +export declare function createRegistry(...input: (Registry | DescFile | DescMessage | DescEnum | DescExtension | DescService)[]): Registry; +/** + * Create a registry that allows adding and removing descriptors. + */ +export declare function createMutableRegistry(...input: (Registry | DescFile | DescMessage | DescEnum | DescExtension | DescService)[]): MutableRegistry; +/** + * Create a registry (including file descriptors) from a google.protobuf.FileDescriptorSet + * message. + */ +export declare function createFileRegistry(fileDescriptorSet: FileDescriptorSet): FileRegistry; +/** + * Create a registry (including file descriptors) from a google.protobuf.FileDescriptorProto + * message. For every import, the given resolver function is called. + */ +export declare function createFileRegistry(fileDescriptorProto: FileDescriptorProto, resolve: (protoFileName: string) => FileDescriptorProto | DescFile | undefined): FileRegistry; +/** + * Create a registry (including file descriptors) from one or more registries, + * merging them. + */ +export declare function createFileRegistry(...registries: FileRegistry[]): FileRegistry; +export declare const minimumEdition: SupportedEdition, maximumEdition: SupportedEdition; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/registry.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/registry.js new file mode 100644 index 0000000000000000000000000000000000000000..6cd14340706f6d63d6ac709ad6b500c40cf43378 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/registry.js @@ -0,0 +1,905 @@ +// Copyright 2021-2025 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. +import { ScalarType, } from "./descriptors.js"; +import { parseTextFormatEnumValue, parseTextFormatScalarValue, } from "./wire/text-format.js"; +import { nestedTypes } from "./reflect/nested-types.js"; +import { unsafeIsSetExplicit } from "./reflect/unsafe.js"; +import { protoCamelCase, safeObjectProperty } from "./reflect/names.js"; +/** + * Create a registry from the given inputs. + * + * An input can be: + * - Any message, enum, service, or extension descriptor, which adds just the + * descriptor for this type. + * - A file descriptor, which adds all typed defined in this file. + * - A registry, which adds all types from the registry. + * + * For duplicate descriptors (same type name), the one given last wins. + */ +export function createRegistry(...input) { + return initBaseRegistry(input); +} +/** + * Create a registry that allows adding and removing descriptors. + */ +export function createMutableRegistry(...input) { + const reg = initBaseRegistry(input); + return Object.assign(Object.assign({}, reg), { remove(desc) { + var _a; + if (desc.kind == "extension") { + (_a = reg.extendees.get(desc.extendee.typeName)) === null || _a === void 0 ? void 0 : _a.delete(desc.number); + } + reg.types.delete(desc.typeName); + } }); +} +export function createFileRegistry(...args) { + const registry = createBaseRegistry(); + if (!args.length) { + return registry; + } + if ("$typeName" in args[0] && + args[0].$typeName == "google.protobuf.FileDescriptorSet") { + for (const file of args[0].file) { + addFile(file, registry); + } + return registry; + } + if ("$typeName" in args[0]) { + const input = args[0]; + const resolve = args[1]; + const seen = new Set(); + function recurseDeps(file) { + const deps = []; + for (const protoFileName of file.dependency) { + if (registry.getFile(protoFileName) != undefined) { + continue; + } + if (seen.has(protoFileName)) { + continue; + } + const dep = resolve(protoFileName); + if (!dep) { + throw new Error(`Unable to resolve ${protoFileName}, imported by ${file.name}`); + } + if ("kind" in dep) { + registry.addFile(dep, false, true); + } + else { + seen.add(dep.name); + deps.push(dep); + } + } + return deps.concat(...deps.map(recurseDeps)); + } + for (const file of [input, ...recurseDeps(input)].reverse()) { + addFile(file, registry); + } + } + else { + for (const fileReg of args) { + for (const file of fileReg.files) { + registry.addFile(file); + } + } + } + return registry; +} +/** + * @private + */ +function createBaseRegistry() { + const types = new Map(); + const extendees = new Map(); + const files = new Map(); + return { + kind: "registry", + types, + extendees, + [Symbol.iterator]() { + return types.values(); + }, + get files() { + return files.values(); + }, + addFile(file, skipTypes, withDeps) { + files.set(file.proto.name, file); + if (!skipTypes) { + for (const type of nestedTypes(file)) { + this.add(type); + } + } + if (withDeps) { + for (const f of file.dependencies) { + this.addFile(f, skipTypes, withDeps); + } + } + }, + add(desc) { + if (desc.kind == "extension") { + let numberToExt = extendees.get(desc.extendee.typeName); + if (!numberToExt) { + extendees.set(desc.extendee.typeName, + // biome-ignore lint/suspicious/noAssignInExpressions: no + (numberToExt = new Map())); + } + numberToExt.set(desc.number, desc); + } + types.set(desc.typeName, desc); + }, + get(typeName) { + return types.get(typeName); + }, + getFile(fileName) { + return files.get(fileName); + }, + getMessage(typeName) { + const t = types.get(typeName); + return (t === null || t === void 0 ? void 0 : t.kind) == "message" ? t : undefined; + }, + getEnum(typeName) { + const t = types.get(typeName); + return (t === null || t === void 0 ? void 0 : t.kind) == "enum" ? t : undefined; + }, + getExtension(typeName) { + const t = types.get(typeName); + return (t === null || t === void 0 ? void 0 : t.kind) == "extension" ? t : undefined; + }, + getExtensionFor(extendee, no) { + var _a; + return (_a = extendees.get(extendee.typeName)) === null || _a === void 0 ? void 0 : _a.get(no); + }, + getService(typeName) { + const t = types.get(typeName); + return (t === null || t === void 0 ? void 0 : t.kind) == "service" ? t : undefined; + }, + }; +} +/** + * @private + */ +function initBaseRegistry(inputs) { + const registry = createBaseRegistry(); + for (const input of inputs) { + switch (input.kind) { + case "registry": + for (const n of input) { + registry.add(n); + } + break; + case "file": + registry.addFile(input); + break; + default: + registry.add(input); + break; + } + } + return registry; +} +// bootstrap-inject google.protobuf.Edition.EDITION_PROTO2: const $name: Edition.$localName = $number; +const EDITION_PROTO2 = 998; +// bootstrap-inject google.protobuf.Edition.EDITION_PROTO3: const $name: Edition.$localName = $number; +const EDITION_PROTO3 = 999; +// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_STRING: const $name: FieldDescriptorProto_Type.$localName = $number; +const TYPE_STRING = 9; +// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_GROUP: const $name: FieldDescriptorProto_Type.$localName = $number; +const TYPE_GROUP = 10; +// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_MESSAGE: const $name: FieldDescriptorProto_Type.$localName = $number; +const TYPE_MESSAGE = 11; +// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_BYTES: const $name: FieldDescriptorProto_Type.$localName = $number; +const TYPE_BYTES = 12; +// bootstrap-inject google.protobuf.FieldDescriptorProto.Type.TYPE_ENUM: const $name: FieldDescriptorProto_Type.$localName = $number; +const TYPE_ENUM = 14; +// bootstrap-inject google.protobuf.FieldDescriptorProto.Label.LABEL_REPEATED: const $name: FieldDescriptorProto_Label.$localName = $number; +const LABEL_REPEATED = 3; +// bootstrap-inject google.protobuf.FieldDescriptorProto.Label.LABEL_REQUIRED: const $name: FieldDescriptorProto_Label.$localName = $number; +const LABEL_REQUIRED = 2; +// bootstrap-inject google.protobuf.FieldOptions.JSType.JS_STRING: const $name: FieldOptions_JSType.$localName = $number; +const JS_STRING = 1; +// bootstrap-inject google.protobuf.MethodOptions.IdempotencyLevel.IDEMPOTENCY_UNKNOWN: const $name: MethodOptions_IdempotencyLevel.$localName = $number; +const IDEMPOTENCY_UNKNOWN = 0; +// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.EXPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number; +const EXPLICIT = 1; +// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number; +const IMPLICIT = 2; +// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name: FeatureSet_FieldPresence.$localName = $number; +const LEGACY_REQUIRED = 3; +// bootstrap-inject google.protobuf.FeatureSet.RepeatedFieldEncoding.PACKED: const $name: FeatureSet_RepeatedFieldEncoding.$localName = $number; +const PACKED = 1; +// bootstrap-inject google.protobuf.FeatureSet.MessageEncoding.DELIMITED: const $name: FeatureSet_MessageEncoding.$localName = $number; +const DELIMITED = 2; +// bootstrap-inject google.protobuf.FeatureSet.EnumType.OPEN: const $name: FeatureSet_EnumType.$localName = $number; +const OPEN = 1; +// biome-ignore format: want this to read well +// bootstrap-inject defaults: EDITION_PROTO2 to EDITION_2023: export const minimumEdition: SupportedEdition = $minimumEdition, maximumEdition: SupportedEdition = $maximumEdition; +// generated from protoc v31.1 +export const minimumEdition = 998, maximumEdition = 1000; +const featureDefaults = { + // EDITION_PROTO2 + 998: { + fieldPresence: 1, // EXPLICIT, + enumType: 2, // CLOSED, + repeatedFieldEncoding: 2, // EXPANDED, + utf8Validation: 3, // NONE, + messageEncoding: 1, // LENGTH_PREFIXED, + jsonFormat: 2, // LEGACY_BEST_EFFORT, + enforceNamingStyle: 2, // STYLE_LEGACY, + defaultSymbolVisibility: 1, // EXPORT_ALL, + }, + // EDITION_PROTO3 + 999: { + fieldPresence: 2, // IMPLICIT, + enumType: 1, // OPEN, + repeatedFieldEncoding: 1, // PACKED, + utf8Validation: 2, // VERIFY, + messageEncoding: 1, // LENGTH_PREFIXED, + jsonFormat: 1, // ALLOW, + enforceNamingStyle: 2, // STYLE_LEGACY, + defaultSymbolVisibility: 1, // EXPORT_ALL, + }, + // EDITION_2023 + 1000: { + fieldPresence: 1, // EXPLICIT, + enumType: 1, // OPEN, + repeatedFieldEncoding: 1, // PACKED, + utf8Validation: 2, // VERIFY, + messageEncoding: 1, // LENGTH_PREFIXED, + jsonFormat: 1, // ALLOW, + enforceNamingStyle: 2, // STYLE_LEGACY, + defaultSymbolVisibility: 1, // EXPORT_ALL, + }, +}; +/** + * Create a descriptor for a file, add it to the registry. + */ +function addFile(proto, reg) { + var _a, _b; + const file = { + kind: "file", + proto, + deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false, + edition: getFileEdition(proto), + name: proto.name.replace(/\.proto$/, ""), + dependencies: findFileDependencies(proto, reg), + enums: [], + messages: [], + extensions: [], + services: [], + toString() { + // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above + return `file ${proto.name}`; + }, + }; + const mapEntriesStore = new Map(); + const mapEntries = { + get(typeName) { + return mapEntriesStore.get(typeName); + }, + add(desc) { + var _a; + assert(((_a = desc.proto.options) === null || _a === void 0 ? void 0 : _a.mapEntry) === true); + mapEntriesStore.set(desc.typeName, desc); + }, + }; + for (const enumProto of proto.enumType) { + addEnum(enumProto, file, undefined, reg); + } + for (const messageProto of proto.messageType) { + addMessage(messageProto, file, undefined, reg, mapEntries); + } + for (const serviceProto of proto.service) { + addService(serviceProto, file, reg); + } + addExtensions(file, reg); + for (const mapEntry of mapEntriesStore.values()) { + // to create a map field, we need access to the map entry's fields + addFields(mapEntry, reg, mapEntries); + } + for (const message of file.messages) { + addFields(message, reg, mapEntries); + addExtensions(message, reg); + } + reg.addFile(file, true); +} +/** + * Create descriptors for extensions, and add them to the message / file, + * and to our cart. + * Recurses into nested types. + */ +function addExtensions(desc, reg) { + switch (desc.kind) { + case "file": + for (const proto of desc.proto.extension) { + const ext = newField(proto, desc, reg); + desc.extensions.push(ext); + reg.add(ext); + } + break; + case "message": + for (const proto of desc.proto.extension) { + const ext = newField(proto, desc, reg); + desc.nestedExtensions.push(ext); + reg.add(ext); + } + for (const message of desc.nestedMessages) { + addExtensions(message, reg); + } + break; + } +} +/** + * Create descriptors for fields and oneof groups, and add them to the message. + * Recurses into nested types. + */ +function addFields(message, reg, mapEntries) { + const allOneofs = message.proto.oneofDecl.map((proto) => newOneof(proto, message)); + const oneofsSeen = new Set(); + for (const proto of message.proto.field) { + const oneof = findOneof(proto, allOneofs); + const field = newField(proto, message, reg, oneof, mapEntries); + message.fields.push(field); + message.field[field.localName] = field; + if (oneof === undefined) { + message.members.push(field); + } + else { + oneof.fields.push(field); + if (!oneofsSeen.has(oneof)) { + oneofsSeen.add(oneof); + message.members.push(oneof); + } + } + } + for (const oneof of allOneofs.filter((o) => oneofsSeen.has(o))) { + message.oneofs.push(oneof); + } + for (const child of message.nestedMessages) { + addFields(child, reg, mapEntries); + } +} +/** + * Create a descriptor for an enumeration, and add it our cart and to the + * parent type, if any. + */ +function addEnum(proto, file, parent, reg) { + var _a, _b, _c, _d, _e; + const sharedPrefix = findEnumSharedPrefix(proto.name, proto.value); + const desc = { + kind: "enum", + proto, + deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false, + file, + parent, + open: true, + name: proto.name, + typeName: makeTypeName(proto, parent, file), + value: {}, + values: [], + sharedPrefix, + toString() { + return `enum ${this.typeName}`; + }, + }; + desc.open = isEnumOpen(desc); + reg.add(desc); + for (const p of proto.value) { + const name = p.name; + desc.values.push( + // biome-ignore lint/suspicious/noAssignInExpressions: no + (desc.value[p.number] = { + kind: "enum_value", + proto: p, + deprecated: (_d = (_c = p.options) === null || _c === void 0 ? void 0 : _c.deprecated) !== null && _d !== void 0 ? _d : false, + parent: desc, + name, + localName: safeObjectProperty(sharedPrefix == undefined + ? name + : name.substring(sharedPrefix.length)), + number: p.number, + toString() { + return `enum value ${desc.typeName}.${name}`; + }, + })); + } + ((_e = parent === null || parent === void 0 ? void 0 : parent.nestedEnums) !== null && _e !== void 0 ? _e : file.enums).push(desc); +} +/** + * Create a descriptor for a message, including nested types, and add it to our + * cart. Note that this does not create descriptors fields. + */ +function addMessage(proto, file, parent, reg, mapEntries) { + var _a, _b, _c, _d; + const desc = { + kind: "message", + proto, + deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false, + file, + parent, + name: proto.name, + typeName: makeTypeName(proto, parent, file), + fields: [], + field: {}, + oneofs: [], + members: [], + nestedEnums: [], + nestedMessages: [], + nestedExtensions: [], + toString() { + return `message ${this.typeName}`; + }, + }; + if (((_c = proto.options) === null || _c === void 0 ? void 0 : _c.mapEntry) === true) { + mapEntries.add(desc); + } + else { + ((_d = parent === null || parent === void 0 ? void 0 : parent.nestedMessages) !== null && _d !== void 0 ? _d : file.messages).push(desc); + reg.add(desc); + } + for (const enumProto of proto.enumType) { + addEnum(enumProto, file, desc, reg); + } + for (const messageProto of proto.nestedType) { + addMessage(messageProto, file, desc, reg, mapEntries); + } +} +/** + * Create a descriptor for a service, including methods, and add it to our + * cart. + */ +function addService(proto, file, reg) { + var _a, _b; + const desc = { + kind: "service", + proto, + deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false, + file, + name: proto.name, + typeName: makeTypeName(proto, undefined, file), + methods: [], + method: {}, + toString() { + return `service ${this.typeName}`; + }, + }; + file.services.push(desc); + reg.add(desc); + for (const methodProto of proto.method) { + const method = newMethod(methodProto, desc, reg); + desc.methods.push(method); + desc.method[method.localName] = method; + } +} +/** + * Create a descriptor for a method. + */ +function newMethod(proto, parent, reg) { + var _a, _b, _c, _d; + let methodKind; + if (proto.clientStreaming && proto.serverStreaming) { + methodKind = "bidi_streaming"; + } + else if (proto.clientStreaming) { + methodKind = "client_streaming"; + } + else if (proto.serverStreaming) { + methodKind = "server_streaming"; + } + else { + methodKind = "unary"; + } + const input = reg.getMessage(trimLeadingDot(proto.inputType)); + const output = reg.getMessage(trimLeadingDot(proto.outputType)); + assert(input, `invalid MethodDescriptorProto: input_type ${proto.inputType} not found`); + assert(output, `invalid MethodDescriptorProto: output_type ${proto.inputType} not found`); + const name = proto.name; + return { + kind: "rpc", + proto, + deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false, + parent, + name, + localName: safeObjectProperty(name.length + ? safeObjectProperty(name[0].toLowerCase() + name.substring(1)) + : name), + methodKind, + input, + output, + idempotency: (_d = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.idempotencyLevel) !== null && _d !== void 0 ? _d : IDEMPOTENCY_UNKNOWN, + toString() { + return `rpc ${parent.typeName}.${name}`; + }, + }; +} +/** + * Create a descriptor for a oneof group. + */ +function newOneof(proto, parent) { + return { + kind: "oneof", + proto, + deprecated: false, + parent, + fields: [], + name: proto.name, + localName: safeObjectProperty(protoCamelCase(proto.name)), + toString() { + return `oneof ${parent.typeName}.${this.name}`; + }, + }; +} +function newField(proto, parentOrFile, reg, oneof, mapEntries) { + var _a, _b, _c; + const isExtension = mapEntries === undefined; + const field = { + kind: "field", + proto, + deprecated: (_b = (_a = proto.options) === null || _a === void 0 ? void 0 : _a.deprecated) !== null && _b !== void 0 ? _b : false, + name: proto.name, + number: proto.number, + scalar: undefined, + message: undefined, + enum: undefined, + presence: getFieldPresence(proto, oneof, isExtension, parentOrFile), + listKind: undefined, + mapKind: undefined, + mapKey: undefined, + delimitedEncoding: undefined, + packed: undefined, + longAsString: false, + getDefaultValue: undefined, + }; + if (isExtension) { + // extension field + const file = parentOrFile.kind == "file" ? parentOrFile : parentOrFile.file; + const parent = parentOrFile.kind == "file" ? undefined : parentOrFile; + const typeName = makeTypeName(proto, parent, file); + field.kind = "extension"; + field.file = file; + field.parent = parent; + field.oneof = undefined; + field.typeName = typeName; + field.jsonName = `[${typeName}]`; // option json_name is not allowed on extension fields + field.toString = () => `extension ${typeName}`; + const extendee = reg.getMessage(trimLeadingDot(proto.extendee)); + assert(extendee, `invalid FieldDescriptorProto: extendee ${proto.extendee} not found`); + field.extendee = extendee; + } + else { + // regular field + const parent = parentOrFile; + assert(parent.kind == "message"); + field.parent = parent; + field.oneof = oneof; + field.localName = oneof + ? protoCamelCase(proto.name) + : safeObjectProperty(protoCamelCase(proto.name)); + field.jsonName = proto.jsonName; + field.toString = () => `field ${parent.typeName}.${proto.name}`; + } + const label = proto.label; + const type = proto.type; + const jstype = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.jstype; + if (label === LABEL_REPEATED) { + // list or map field + const mapEntry = type == TYPE_MESSAGE + ? mapEntries === null || mapEntries === void 0 ? void 0 : mapEntries.get(trimLeadingDot(proto.typeName)) + : undefined; + if (mapEntry) { + // map field + field.fieldKind = "map"; + const { key, value } = findMapEntryFields(mapEntry); + field.mapKey = key.scalar; + field.mapKind = value.fieldKind; + field.message = value.message; + field.delimitedEncoding = false; // map fields are always LENGTH_PREFIXED + field.enum = value.enum; + field.scalar = value.scalar; + return field; + } + // list field + field.fieldKind = "list"; + switch (type) { + case TYPE_MESSAGE: + case TYPE_GROUP: + field.listKind = "message"; + field.message = reg.getMessage(trimLeadingDot(proto.typeName)); + assert(field.message); + field.delimitedEncoding = isDelimitedEncoding(proto, parentOrFile); + break; + case TYPE_ENUM: + field.listKind = "enum"; + field.enum = reg.getEnum(trimLeadingDot(proto.typeName)); + assert(field.enum); + break; + default: + field.listKind = "scalar"; + field.scalar = type; + field.longAsString = jstype == JS_STRING; + break; + } + field.packed = isPackedField(proto, parentOrFile); + return field; + } + // singular + switch (type) { + case TYPE_MESSAGE: + case TYPE_GROUP: + field.fieldKind = "message"; + field.message = reg.getMessage(trimLeadingDot(proto.typeName)); + assert(field.message, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`); + field.delimitedEncoding = isDelimitedEncoding(proto, parentOrFile); + field.getDefaultValue = () => undefined; + break; + case TYPE_ENUM: { + const enumeration = reg.getEnum(trimLeadingDot(proto.typeName)); + assert(enumeration !== undefined, `invalid FieldDescriptorProto: type_name ${proto.typeName} not found`); + field.fieldKind = "enum"; + field.enum = reg.getEnum(trimLeadingDot(proto.typeName)); + field.getDefaultValue = () => { + return unsafeIsSetExplicit(proto, "defaultValue") + ? parseTextFormatEnumValue(enumeration, proto.defaultValue) + : undefined; + }; + break; + } + default: { + field.fieldKind = "scalar"; + field.scalar = type; + field.longAsString = jstype == JS_STRING; + field.getDefaultValue = () => { + return unsafeIsSetExplicit(proto, "defaultValue") + ? parseTextFormatScalarValue(type, proto.defaultValue) + : undefined; + }; + break; + } + } + return field; +} +/** + * Parse the "syntax" and "edition" fields, returning one of the supported + * editions. + */ +function getFileEdition(proto) { + switch (proto.syntax) { + case "": + case "proto2": + return EDITION_PROTO2; + case "proto3": + return EDITION_PROTO3; + case "editions": + if (proto.edition in featureDefaults) { + return proto.edition; + } + throw new Error(`${proto.name}: unsupported edition`); + default: + throw new Error(`${proto.name}: unsupported syntax "${proto.syntax}"`); + } +} +/** + * Resolve dependencies of FileDescriptorProto to DescFile. + */ +function findFileDependencies(proto, reg) { + return proto.dependency.map((wantName) => { + const dep = reg.getFile(wantName); + if (!dep) { + throw new Error(`Cannot find ${wantName}, imported by ${proto.name}`); + } + return dep; + }); +} +/** + * Finds a prefix shared by enum values, for example `my_enum_` for + * `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`. + */ +function findEnumSharedPrefix(enumName, values) { + const prefix = camelToSnakeCase(enumName) + "_"; + for (const value of values) { + if (!value.name.toLowerCase().startsWith(prefix)) { + return undefined; + } + const shortName = value.name.substring(prefix.length); + if (shortName.length == 0) { + return undefined; + } + if (/^\d/.test(shortName)) { + // identifiers must not start with numbers + return undefined; + } + } + return prefix; +} +/** + * Converts lowerCamelCase or UpperCamelCase into lower_snake_case. + * This is used to find shared prefixes in an enum. + */ +function camelToSnakeCase(camel) { + return (camel.substring(0, 1) + camel.substring(1).replace(/[A-Z]/g, (c) => "_" + c)).toLowerCase(); +} +/** + * Create a fully qualified name for a protobuf type or extension field. + * + * The fully qualified name for messages, enumerations, and services is + * constructed by concatenating the package name (if present), parent + * message names (for nested types), and the type name. We omit the leading + * dot added by protobuf compilers. Examples: + * - mypackage.MyMessage + * - mypackage.MyMessage.NestedMessage + * + * The fully qualified name for extension fields is constructed by + * concatenating the package name (if present), parent message names (for + * extensions declared within a message), and the field name. Examples: + * - mypackage.extfield + * - mypackage.MyMessage.extfield + */ +function makeTypeName(proto, parent, file) { + let typeName; + if (parent) { + typeName = `${parent.typeName}.${proto.name}`; + } + else if (file.proto.package.length > 0) { + typeName = `${file.proto.package}.${proto.name}`; + } + else { + typeName = `${proto.name}`; + } + return typeName; +} +/** + * Remove the leading dot from a fully qualified type name. + */ +function trimLeadingDot(typeName) { + return typeName.startsWith(".") ? typeName.substring(1) : typeName; +} +/** + * Did the user put the field in a oneof group? + * Synthetic oneofs for proto3 optionals are ignored. + */ +function findOneof(proto, allOneofs) { + if (!unsafeIsSetExplicit(proto, "oneofIndex")) { + return undefined; + } + if (proto.proto3Optional) { + return undefined; + } + const oneof = allOneofs[proto.oneofIndex]; + assert(oneof, `invalid FieldDescriptorProto: oneof #${proto.oneofIndex} for field #${proto.number} not found`); + return oneof; +} +/** + * Presence of the field. + * See https://protobuf.dev/programming-guides/field_presence/ + */ +function getFieldPresence(proto, oneof, isExtension, parent) { + if (proto.label == LABEL_REQUIRED) { + // proto2 required is LEGACY_REQUIRED + return LEGACY_REQUIRED; + } + if (proto.label == LABEL_REPEATED) { + // repeated fields (including maps) do not track presence + return IMPLICIT; + } + if (!!oneof || proto.proto3Optional) { + // oneof is always explicit + return EXPLICIT; + } + if (isExtension) { + // extensions always track presence + return EXPLICIT; + } + const resolved = resolveFeature("fieldPresence", { proto, parent }); + if (resolved == IMPLICIT && + (proto.type == TYPE_MESSAGE || proto.type == TYPE_GROUP)) { + // singular message field cannot be implicit + return EXPLICIT; + } + return resolved; +} +/** + * Pack this repeated field? + */ +function isPackedField(proto, parent) { + if (proto.label != LABEL_REPEATED) { + return false; + } + switch (proto.type) { + case TYPE_STRING: + case TYPE_BYTES: + case TYPE_GROUP: + case TYPE_MESSAGE: + // length-delimited types cannot be packed + return false; + } + const o = proto.options; + if (o && unsafeIsSetExplicit(o, "packed")) { + // prefer the field option over edition features + return o.packed; + } + return (PACKED == + resolveFeature("repeatedFieldEncoding", { + proto, + parent, + })); +} +/** + * Find the key and value fields of a synthetic map entry message. + */ +function findMapEntryFields(mapEntry) { + const key = mapEntry.fields.find((f) => f.number === 1); + const value = mapEntry.fields.find((f) => f.number === 2); + assert(key && + key.fieldKind == "scalar" && + key.scalar != ScalarType.BYTES && + key.scalar != ScalarType.FLOAT && + key.scalar != ScalarType.DOUBLE && + value && + value.fieldKind != "list" && + value.fieldKind != "map"); + return { key, value }; +} +/** + * Enumerations can be open or closed. + * See https://protobuf.dev/programming-guides/enum/ + */ +function isEnumOpen(desc) { + var _a; + return (OPEN == + resolveFeature("enumType", { + proto: desc.proto, + parent: (_a = desc.parent) !== null && _a !== void 0 ? _a : desc.file, + })); +} +/** + * Encode the message delimited (a.k.a. proto2 group encoding), or + * length-prefixed? + */ +function isDelimitedEncoding(proto, parent) { + if (proto.type == TYPE_GROUP) { + return true; + } + return (DELIMITED == + resolveFeature("messageEncoding", { + proto, + parent, + })); +} +function resolveFeature(name, ref) { + var _a, _b; + const featureSet = (_a = ref.proto.options) === null || _a === void 0 ? void 0 : _a.features; + if (featureSet) { + const val = featureSet[name]; + if (val != 0) { + return val; + } + } + if ("kind" in ref) { + if (ref.kind == "message") { + return resolveFeature(name, (_b = ref.parent) !== null && _b !== void 0 ? _b : ref.file); + } + const editionDefaults = featureDefaults[ref.edition]; + if (!editionDefaults) { + throw new Error(`feature default for edition ${ref.edition} not found`); + } + return editionDefaults[name]; + } + return resolveFeature(name, ref.parent); +} +/** + * Assert that condition is truthy or throw error (with message) + */ +function assert(condition, msg) { + if (!condition) { + throw new Error(msg); + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/to-binary.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/to-binary.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..236ed49ade70cdf0150699025e7550ac563363fe --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/to-binary.d.ts @@ -0,0 +1,24 @@ +import type { MessageShape } from "./types.js"; +import { BinaryWriter } from "./wire/binary-encoding.js"; +import { type DescField, type DescMessage } from "./descriptors.js"; +import type { ReflectMessage } from "./reflect/index.js"; +/** + * Options for serializing to binary data. + * + * V1 also had the option `readerFactory` for using a custom implementation to + * encode to binary. + */ +export interface BinaryWriteOptions { + /** + * Include unknown fields in the serialized output? The default behavior + * is to retain unknown fields and include them in the serialized output. + * + * For more details see https://developers.google.com/protocol-buffers/docs/proto3#unknowns + */ + writeUnknownFields: boolean; +} +export declare function toBinary(schema: Desc, message: MessageShape, options?: Partial): Uint8Array; +/** + * @private + */ +export declare function writeField(writer: BinaryWriter, opts: BinaryWriteOptions, msg: ReflectMessage, field: DescField): void; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/to-binary.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/to-binary.js new file mode 100644 index 0000000000000000000000000000000000000000..f905a43b0278c8badb34648b86cf4eb9f3f988a2 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/to-binary.js @@ -0,0 +1,195 @@ +// Copyright 2021-2025 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. +import { reflect } from "./reflect/reflect.js"; +import { BinaryWriter, WireType } from "./wire/binary-encoding.js"; +import { ScalarType } from "./descriptors.js"; +// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name: FeatureSet_FieldPresence.$localName = $number; +const LEGACY_REQUIRED = 3; +// Default options for serializing binary data. +const writeDefaults = { + writeUnknownFields: true, +}; +function makeWriteOptions(options) { + return options ? Object.assign(Object.assign({}, writeDefaults), options) : writeDefaults; +} +export function toBinary(schema, message, options) { + return writeFields(new BinaryWriter(), makeWriteOptions(options), reflect(schema, message)).finish(); +} +function writeFields(writer, opts, msg) { + var _a; + for (const f of msg.sortedFields) { + if (!msg.isSet(f)) { + if (f.presence == LEGACY_REQUIRED) { + throw new Error(`cannot encode ${f} to binary: required field not set`); + } + continue; + } + writeField(writer, opts, msg, f); + } + if (opts.writeUnknownFields) { + for (const { no, wireType, data } of (_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : []) { + writer.tag(no, wireType).raw(data); + } + } + return writer; +} +/** + * @private + */ +export function writeField(writer, opts, msg, field) { + var _a; + switch (field.fieldKind) { + case "scalar": + case "enum": + writeScalar(writer, msg.desc.typeName, field.name, (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32, field.number, msg.get(field)); + break; + case "list": + writeListField(writer, opts, field, msg.get(field)); + break; + case "message": + writeMessageField(writer, opts, field, msg.get(field)); + break; + case "map": + for (const [key, val] of msg.get(field)) { + writeMapEntry(writer, opts, field, key, val); + } + break; + } +} +function writeScalar(writer, msgName, fieldName, scalarType, fieldNo, value) { + writeScalarValue(writer.tag(fieldNo, writeTypeOfScalar(scalarType)), msgName, fieldName, scalarType, value); +} +function writeMessageField(writer, opts, field, message) { + if (field.delimitedEncoding) { + writeFields(writer.tag(field.number, WireType.StartGroup), opts, message).tag(field.number, WireType.EndGroup); + } + else { + writeFields(writer.tag(field.number, WireType.LengthDelimited).fork(), opts, message).join(); + } +} +function writeListField(writer, opts, field, list) { + var _a; + if (field.listKind == "message") { + for (const item of list) { + writeMessageField(writer, opts, field, item); + } + return; + } + const scalarType = (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32; + if (field.packed) { + if (!list.size) { + return; + } + writer.tag(field.number, WireType.LengthDelimited).fork(); + for (const item of list) { + writeScalarValue(writer, field.parent.typeName, field.name, scalarType, item); + } + writer.join(); + return; + } + for (const item of list) { + writeScalar(writer, field.parent.typeName, field.name, scalarType, field.number, item); + } +} +function writeMapEntry(writer, opts, field, key, value) { + var _a; + writer.tag(field.number, WireType.LengthDelimited).fork(); + // write key, expecting key field number = 1 + writeScalar(writer, field.parent.typeName, field.name, field.mapKey, 1, key); + // write value, expecting value field number = 2 + switch (field.mapKind) { + case "scalar": + case "enum": + writeScalar(writer, field.parent.typeName, field.name, (_a = field.scalar) !== null && _a !== void 0 ? _a : ScalarType.INT32, 2, value); + break; + case "message": + writeFields(writer.tag(2, WireType.LengthDelimited).fork(), opts, value).join(); + break; + } + writer.join(); +} +function writeScalarValue(writer, msgName, fieldName, type, value) { + try { + switch (type) { + case ScalarType.STRING: + writer.string(value); + break; + case ScalarType.BOOL: + writer.bool(value); + break; + case ScalarType.DOUBLE: + writer.double(value); + break; + case ScalarType.FLOAT: + writer.float(value); + break; + case ScalarType.INT32: + writer.int32(value); + break; + case ScalarType.INT64: + writer.int64(value); + break; + case ScalarType.UINT64: + writer.uint64(value); + break; + case ScalarType.FIXED64: + writer.fixed64(value); + break; + case ScalarType.BYTES: + writer.bytes(value); + break; + case ScalarType.FIXED32: + writer.fixed32(value); + break; + case ScalarType.SFIXED32: + writer.sfixed32(value); + break; + case ScalarType.SFIXED64: + writer.sfixed64(value); + break; + case ScalarType.SINT64: + writer.sint64(value); + break; + case ScalarType.UINT32: + writer.uint32(value); + break; + case ScalarType.SINT32: + writer.sint32(value); + break; + } + } + catch (e) { + if (e instanceof Error) { + throw new Error(`cannot encode field ${msgName}.${fieldName} to binary: ${e.message}`); + } + throw e; + } +} +function writeTypeOfScalar(type) { + switch (type) { + case ScalarType.BYTES: + case ScalarType.STRING: + return WireType.LengthDelimited; + case ScalarType.DOUBLE: + case ScalarType.FIXED64: + case ScalarType.SFIXED64: + return WireType.Bit64; + case ScalarType.FIXED32: + case ScalarType.SFIXED32: + case ScalarType.FLOAT: + return WireType.Bit32; + default: + return WireType.Varint; + } +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/to-json.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/to-json.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f15b9b53a4479839dc4300d458ae1d719befe096 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/to-json.d.ts @@ -0,0 +1,67 @@ +import { type DescEnum, type DescMessage } from "./descriptors.js"; +import type { JsonValue } from "./json-value.js"; +import type { Registry } from "./registry.js"; +import type { EnumJsonType, EnumShape, MessageJsonType, MessageShape } from "./types.js"; +/** + * Options for serializing to JSON. + */ +export interface JsonWriteOptions { + /** + * By default, fields with implicit presence are not serialized if they are + * unset. For example, an empty list field or a proto3 int32 field with 0 is + * not serialized. With this option enabled, such fields are included in the + * output. + */ + alwaysEmitImplicit: boolean; + /** + * Emit enum values as integers instead of strings: The name of an enum + * value is used by default in JSON output. An option may be provided to + * use the numeric value of the enum value instead. + */ + enumAsInteger: boolean; + /** + * Use proto field name instead of lowerCamelCase name: By default proto3 + * JSON printer should convert the field name to lowerCamelCase and use + * that as the JSON name. An implementation may provide an option to use + * proto field name as the JSON name instead. Proto3 JSON parsers are + * required to accept both the converted lowerCamelCase name and the proto + * field name. + */ + useProtoFieldName: boolean; + /** + * This option is required to write `google.protobuf.Any` and extensions + * to JSON format. + */ + registry?: Registry; +} +/** + * Options for serializing to JSON. + */ +export interface JsonWriteStringOptions extends JsonWriteOptions { + /** + * Format JSON with indentation. Indicates the number of space characters to + * be used as indentation. + * + * This option is passed to JSON.stringify as `space`. + */ + prettySpaces: number; +} +/** + * Serialize the message to a JSON value, a JavaScript value that can be + * passed to JSON.stringify(). + */ +export declare function toJson | undefined = undefined>(schema: Desc, message: MessageShape, options?: Opts): ToJson; +type ToJson> = Opts extends undefined | { + alwaysEmitImplicit?: false; + enumAsInteger?: false; + useProtoFieldName?: false; +} ? MessageJsonType : JsonValue; +/** + * Serialize the message to a JSON string. + */ +export declare function toJsonString(schema: Desc, message: MessageShape, options?: Partial): string; +/** + * Serialize a single enum value to JSON. + */ +export declare function enumToJson(descEnum: Desc, value: EnumShape): EnumJsonType; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/to-json.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/to-json.js new file mode 100644 index 0000000000000000000000000000000000000000..e1e35516f28b7fd010c098a311d3dbee1add5682 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/to-json.js @@ -0,0 +1,382 @@ +// Copyright 2021-2025 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. +import { ScalarType, } from "./descriptors.js"; +import { protoCamelCase } from "./reflect/names.js"; +import { reflect } from "./reflect/reflect.js"; +import { anyUnpack } from "./wkt/index.js"; +import { isWrapperDesc } from "./wkt/wrappers.js"; +import { base64Encode } from "./wire/index.js"; +import { createExtensionContainer, getExtension } from "./extensions.js"; +import { checkField, formatVal } from "./reflect/reflect-check.js"; +// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.LEGACY_REQUIRED: const $name: FeatureSet_FieldPresence.$localName = $number; +const LEGACY_REQUIRED = 3; +// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number; +const IMPLICIT = 2; +// Default options for serializing to JSON. +const jsonWriteDefaults = { + alwaysEmitImplicit: false, + enumAsInteger: false, + useProtoFieldName: false, +}; +function makeWriteOptions(options) { + return options ? Object.assign(Object.assign({}, jsonWriteDefaults), options) : jsonWriteDefaults; +} +/** + * Serialize the message to a JSON value, a JavaScript value that can be + * passed to JSON.stringify(). + */ +export function toJson(schema, message, options) { + return reflectToJson(reflect(schema, message), makeWriteOptions(options)); +} +/** + * Serialize the message to a JSON string. + */ +export function toJsonString(schema, message, options) { + var _a; + const jsonValue = toJson(schema, message, options); + return JSON.stringify(jsonValue, null, (_a = options === null || options === void 0 ? void 0 : options.prettySpaces) !== null && _a !== void 0 ? _a : 0); +} +/** + * Serialize a single enum value to JSON. + */ +export function enumToJson(descEnum, value) { + var _a; + if (descEnum.typeName == "google.protobuf.NullValue") { + return null; + } + const name = (_a = descEnum.value[value]) === null || _a === void 0 ? void 0 : _a.name; + if (name === undefined) { + throw new Error(`${value} is not a value in ${descEnum}`); + } + return name; +} +function reflectToJson(msg, opts) { + var _a; + const wktJson = tryWktToJson(msg, opts); + if (wktJson !== undefined) + return wktJson; + const json = {}; + for (const f of msg.sortedFields) { + if (!msg.isSet(f)) { + if (f.presence == LEGACY_REQUIRED) { + throw new Error(`cannot encode ${f} to JSON: required field not set`); + } + if (!opts.alwaysEmitImplicit || f.presence !== IMPLICIT) { + // Fields with implicit presence omit zero values (e.g. empty string) by default + continue; + } + } + const jsonValue = fieldToJson(f, msg.get(f), opts); + if (jsonValue !== undefined) { + json[jsonName(f, opts)] = jsonValue; + } + } + if (opts.registry) { + const tagSeen = new Set(); + for (const { no } of (_a = msg.getUnknown()) !== null && _a !== void 0 ? _a : []) { + // Same tag can appear multiple times, so we + // keep track and skip identical ones. + if (!tagSeen.has(no)) { + tagSeen.add(no); + const extension = opts.registry.getExtensionFor(msg.desc, no); + if (!extension) { + continue; + } + const value = getExtension(msg.message, extension); + const [container, field] = createExtensionContainer(extension, value); + const jsonValue = fieldToJson(field, container.get(field), opts); + if (jsonValue !== undefined) { + json[extension.jsonName] = jsonValue; + } + } + } + } + return json; +} +function fieldToJson(f, val, opts) { + switch (f.fieldKind) { + case "scalar": + return scalarToJson(f, val); + case "message": + return reflectToJson(val, opts); + case "enum": + return enumToJsonInternal(f.enum, val, opts.enumAsInteger); + case "list": + return listToJson(val, opts); + case "map": + return mapToJson(val, opts); + } +} +function mapToJson(map, opts) { + const f = map.field(); + const jsonObj = {}; + switch (f.mapKind) { + case "scalar": + for (const [entryKey, entryValue] of map) { + jsonObj[entryKey] = scalarToJson(f, entryValue); + } + break; + case "message": + for (const [entryKey, entryValue] of map) { + jsonObj[entryKey] = reflectToJson(entryValue, opts); + } + break; + case "enum": + for (const [entryKey, entryValue] of map) { + jsonObj[entryKey] = enumToJsonInternal(f.enum, entryValue, opts.enumAsInteger); + } + break; + } + return opts.alwaysEmitImplicit || map.size > 0 ? jsonObj : undefined; +} +function listToJson(list, opts) { + const f = list.field(); + const jsonArr = []; + switch (f.listKind) { + case "scalar": + for (const item of list) { + jsonArr.push(scalarToJson(f, item)); + } + break; + case "enum": + for (const item of list) { + jsonArr.push(enumToJsonInternal(f.enum, item, opts.enumAsInteger)); + } + break; + case "message": + for (const item of list) { + jsonArr.push(reflectToJson(item, opts)); + } + break; + } + return opts.alwaysEmitImplicit || jsonArr.length > 0 ? jsonArr : undefined; +} +function enumToJsonInternal(desc, value, enumAsInteger) { + var _a; + if (typeof value != "number") { + throw new Error(`cannot encode ${desc} to JSON: expected number, got ${formatVal(value)}`); + } + if (desc.typeName == "google.protobuf.NullValue") { + return null; + } + if (enumAsInteger) { + return value; + } + const val = desc.value[value]; + return (_a = val === null || val === void 0 ? void 0 : val.name) !== null && _a !== void 0 ? _a : value; // if we don't know the enum value, just return the number +} +function scalarToJson(field, value) { + var _a, _b, _c, _d, _e, _f; + switch (field.scalar) { + // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted. + case ScalarType.INT32: + case ScalarType.SFIXED32: + case ScalarType.SINT32: + case ScalarType.FIXED32: + case ScalarType.UINT32: + if (typeof value != "number") { + throw new Error(`cannot encode ${field} to JSON: ${(_a = checkField(field, value)) === null || _a === void 0 ? void 0 : _a.message}`); + } + return value; + // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity". + // Either numbers or strings are accepted. Exponent notation is also accepted. + case ScalarType.FLOAT: + case ScalarType.DOUBLE: // eslint-disable-line no-fallthrough + if (typeof value != "number") { + throw new Error(`cannot encode ${field} to JSON: ${(_b = checkField(field, value)) === null || _b === void 0 ? void 0 : _b.message}`); + } + if (Number.isNaN(value)) + return "NaN"; + if (value === Number.POSITIVE_INFINITY) + return "Infinity"; + if (value === Number.NEGATIVE_INFINITY) + return "-Infinity"; + return value; + // string: + case ScalarType.STRING: + if (typeof value != "string") { + throw new Error(`cannot encode ${field} to JSON: ${(_c = checkField(field, value)) === null || _c === void 0 ? void 0 : _c.message}`); + } + return value; + // bool: + case ScalarType.BOOL: + if (typeof value != "boolean") { + throw new Error(`cannot encode ${field} to JSON: ${(_d = checkField(field, value)) === null || _d === void 0 ? void 0 : _d.message}`); + } + return value; + // JSON value will be a decimal string. Either numbers or strings are accepted. + case ScalarType.UINT64: + case ScalarType.FIXED64: + case ScalarType.INT64: + case ScalarType.SFIXED64: + case ScalarType.SINT64: + if (typeof value != "bigint" && typeof value != "string") { + throw new Error(`cannot encode ${field} to JSON: ${(_e = checkField(field, value)) === null || _e === void 0 ? void 0 : _e.message}`); + } + return value.toString(); + // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings. + // Either standard or URL-safe base64 encoding with/without paddings are accepted. + case ScalarType.BYTES: + if (value instanceof Uint8Array) { + return base64Encode(value); + } + throw new Error(`cannot encode ${field} to JSON: ${(_f = checkField(field, value)) === null || _f === void 0 ? void 0 : _f.message}`); + } +} +function jsonName(f, opts) { + return opts.useProtoFieldName ? f.name : f.jsonName; +} +// returns a json value if wkt, otherwise returns undefined. +function tryWktToJson(msg, opts) { + if (!msg.desc.typeName.startsWith("google.protobuf.")) { + return undefined; + } + switch (msg.desc.typeName) { + case "google.protobuf.Any": + return anyToJson(msg.message, opts); + case "google.protobuf.Timestamp": + return timestampToJson(msg.message); + case "google.protobuf.Duration": + return durationToJson(msg.message); + case "google.protobuf.FieldMask": + return fieldMaskToJson(msg.message); + case "google.protobuf.Struct": + return structToJson(msg.message); + case "google.protobuf.Value": + return valueToJson(msg.message); + case "google.protobuf.ListValue": + return listValueToJson(msg.message); + default: + if (isWrapperDesc(msg.desc)) { + const valueField = msg.desc.fields[0]; + return scalarToJson(valueField, msg.get(valueField)); + } + return undefined; + } +} +function anyToJson(val, opts) { + if (val.typeUrl === "") { + return {}; + } + const { registry } = opts; + let message; + let desc; + if (registry) { + message = anyUnpack(val, registry); + if (message) { + desc = registry.getMessage(message.$typeName); + } + } + if (!desc || !message) { + throw new Error(`cannot encode message ${val.$typeName} to JSON: "${val.typeUrl}" is not in the type registry`); + } + let json = reflectToJson(reflect(desc, message), opts); + if (desc.typeName.startsWith("google.protobuf.") || + json === null || + Array.isArray(json) || + typeof json !== "object") { + json = { value: json }; + } + json["@type"] = val.typeUrl; + return json; +} +function durationToJson(val) { + if (Number(val.seconds) > 315576000000 || + Number(val.seconds) < -315576000000) { + throw new Error(`cannot encode message ${val.$typeName} to JSON: value out of range`); + } + let text = val.seconds.toString(); + if (val.nanos !== 0) { + let nanosStr = Math.abs(val.nanos).toString(); + nanosStr = "0".repeat(9 - nanosStr.length) + nanosStr; + if (nanosStr.substring(3) === "000000") { + nanosStr = nanosStr.substring(0, 3); + } + else if (nanosStr.substring(6) === "000") { + nanosStr = nanosStr.substring(0, 6); + } + text += "." + nanosStr; + if (val.nanos < 0 && Number(val.seconds) == 0) { + text = "-" + text; + } + } + return text + "s"; +} +function fieldMaskToJson(val) { + return val.paths + .map((p) => { + if (p.match(/_[0-9]?_/g) || p.match(/[A-Z]/g)) { + throw new Error(`cannot encode message ${val.$typeName} to JSON: lowerCamelCase of path name "` + + p + + '" is irreversible'); + } + return protoCamelCase(p); + }) + .join(","); +} +function structToJson(val) { + const json = {}; + for (const [k, v] of Object.entries(val.fields)) { + json[k] = valueToJson(v); + } + return json; +} +function valueToJson(val) { + switch (val.kind.case) { + case "nullValue": + return null; + case "numberValue": + if (!Number.isFinite(val.kind.value)) { + throw new Error(`${val.$typeName} cannot be NaN or Infinity`); + } + return val.kind.value; + case "boolValue": + return val.kind.value; + case "stringValue": + return val.kind.value; + case "structValue": + return structToJson(val.kind.value); + case "listValue": + return listValueToJson(val.kind.value); + default: + throw new Error(`${val.$typeName} must have a value`); + } +} +function listValueToJson(val) { + return val.values.map(valueToJson); +} +function timestampToJson(val) { + const ms = Number(val.seconds) * 1000; + if (ms < Date.parse("0001-01-01T00:00:00Z") || + ms > Date.parse("9999-12-31T23:59:59Z")) { + throw new Error(`cannot encode message ${val.$typeName} to JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`); + } + if (val.nanos < 0) { + throw new Error(`cannot encode message ${val.$typeName} to JSON: nanos must not be negative`); + } + let z = "Z"; + if (val.nanos > 0) { + const nanosStr = (val.nanos + 1000000000).toString().substring(1); + if (nanosStr.substring(3) === "000000") { + z = "." + nanosStr.substring(0, 3) + "Z"; + } + else if (nanosStr.substring(6) === "000") { + z = "." + nanosStr.substring(0, 6) + "Z"; + } + else { + z = "." + nanosStr + "Z"; + } + } + return new Date(ms).toISOString().replace(".000Z", z); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/types.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/types.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..93e4effbfd1e6f30d67016325e6121d30b320d6b --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/types.d.ts @@ -0,0 +1,128 @@ +import type { GenEnum as GenEnumV1, GenExtension as GenExtensionV1, GenMessage as GenMessageV1 } from "./codegenv1/types.js"; +import type { GenEnum as GenEnumV2, GenExtension as GenExtensionV2, GenMessage as GenMessageV2 } from "./codegenv2/types.js"; +import type { DescEnum, DescExtension, DescMessage, DescMethod } from "./descriptors.js"; +import type { OneofADT } from "./reflect/guard.js"; +import type { WireType } from "./wire/index.js"; +import type { JsonValue } from "./json-value.js"; +/** + * The type `Message` contains the properties shared by all messages. + */ +export type Message = { + /** + * The fully qualified Protobuf type-name of the message. + */ + readonly $typeName: TypeName; + /** + * Unknown fields and extensions stored on the message. + */ + $unknown?: UnknownField[]; +}; +/** + * Extract the message type from a message descriptor. + */ +export type MessageShape = Desc extends GenMessageV1 ? RuntimeShapeV1 : Desc extends GenMessageV2 ? RuntimeShape : Message; +/** + * Extract the message JSON type from a message descriptor. + * + * JSON types are only available for code generated with the plugin option + * `json_types=true`. If JSON types are unavailable, this type falls back to the + * `JsonValue` type. + */ +export type MessageJsonType = Desc extends GenMessageV1 ? JsonTypeV1 : Desc extends GenMessageV2 ? JsonType : JsonValue; +/** + * Extract the message Valid type from a message descriptor. + * + * Valid types are only available for code generated with the plugin option + * `valid_types`. If Valid types are unavailable, this type falls back to the + * regular message shape. + */ +export type MessageValidType = Desc extends GenMessageV1 ? RuntimeShapeV1 : Desc extends GenMessageV2 ? ValidType : Desc extends GenMessageV2 ? RuntimeShape : Message; +/** + * Extract the init type from a message descriptor. + * The init type is accepted by the function create(). + */ +export type MessageInitShape = Desc extends GenMessageV1 ? MessageInit : Desc extends GenMessageV2 ? MessageInit : Record; +/** + * Extract the enum type of from an enum descriptor. + */ +export type EnumShape = Desc extends GenEnumV1 ? RuntimeShape : Desc extends GenEnumV2 ? RuntimeShape : number; +/** + * Extract the enum JSON type from a enum descriptor. + */ +export type EnumJsonType = Desc extends GenEnumV1 ? JsonType : Desc extends GenEnumV2 ? JsonType : string | null; +/** + * Extract the value type from an extension descriptor. + */ +export type ExtensionValueShape = Desc extends GenExtensionV1 ? RuntimeShape : Desc extends GenExtensionV2 ? RuntimeShape : unknown; +/** + * Extract the type of the extended message from an extension descriptor. + */ +export type Extendee = Desc extends GenExtensionV1 ? Extendee : Desc extends GenExtensionV2 ? Extendee : Message; +/** + * Unknown fields are fields that were not recognized during parsing, or + * extension. + */ +export type UnknownField = { + readonly no: number; + readonly wireType: WireType; + readonly data: Uint8Array; +}; +/** + * Describes a streaming RPC declaration. + */ +export type DescMethodStreaming = DescMethodClientStreaming | DescMethodServerStreaming | DescMethodBiDiStreaming; +/** + * Describes a unary RPC declaration. + */ +export type DescMethodUnary = DescMethodTyped<"unary", I, O>; +/** + * Describes a server streaming RPC declaration. + */ +export type DescMethodServerStreaming = DescMethodTyped<"server_streaming", I, O>; +/** + * Describes a client streaming RPC declaration. + */ +export type DescMethodClientStreaming = DescMethodTyped<"client_streaming", I, O>; +/** + * Describes a bidi streaming RPC declaration. + */ +export type DescMethodBiDiStreaming = DescMethodTyped<"bidi_streaming", I, O>; +/** + * The init type for a message, which makes all fields optional. + * The init type is accepted by the function create(). + */ +type MessageInit = T | { + [P in keyof T as P extends "$unknown" ? never : P]?: P extends "$typeName" ? never : FieldInit; +}; +type FieldInit = F extends (Date | Uint8Array | bigint | boolean | string | number) ? F : F extends Array ? Array> : F extends ReadonlyArray ? ReadonlyArray> : F extends Message ? MessageInit : F extends OneofSelectedMessage ? { + case: C; + value: MessageInit; +} : F extends OneofADT ? F : F extends MapWithMessage ? { + [key: string | number]: MessageInit; +} : F; +type MapWithMessage = { + [key: string | number]: V; +}; +type OneofSelectedMessage = { + case: K; + value: M; +}; +type DescMethodTyped = Omit & { + /** + * One of the four available method types. + */ + readonly methodKind: K; + /** + * The message type for requests. + */ + readonly input: I; + /** + * The message type for responses. + */ + readonly output: O; +}; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/types.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/types.js new file mode 100644 index 0000000000000000000000000000000000000000..f9c447989619ad243c8fb60cf167ed1be96ee713 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/types.js @@ -0,0 +1,14 @@ +// Copyright 2021-2025 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. +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/base64-encoding.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/base64-encoding.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..bbe3d7dd280cae08c4b9bb30287ebd371f23c52d --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/base64-encoding.d.ts @@ -0,0 +1,23 @@ +/** + * Decodes a base64 string to a byte array. + * + * - ignores white-space, including line breaks and tabs + * - allows inner padding (can decode concatenated base64 strings) + * - does not require padding + * - understands base64url encoding: + * "-" instead of "+", + * "_" instead of "/", + * no padding + */ +export declare function base64Decode(base64Str: string): Uint8Array; +/** + * Encode a byte array to a base64 string. + * + * By default, this function uses the standard base64 encoding with padding. + * + * To encode without padding, use encoding = "std_raw". + * + * To encode with the URL encoding, use encoding = "url", which replaces the + * characters +/ by their URL-safe counterparts -_, and omits padding. + */ +export declare function base64Encode(bytes: Uint8Array, encoding?: "std" | "std_raw" | "url"): string; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/base64-encoding.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/base64-encoding.js new file mode 100644 index 0000000000000000000000000000000000000000..0defc5ff0867c2079dd7346620c7ce6050ab70a5 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/base64-encoding.js @@ -0,0 +1,152 @@ +// Copyright 2021-2025 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. +/** + * Decodes a base64 string to a byte array. + * + * - ignores white-space, including line breaks and tabs + * - allows inner padding (can decode concatenated base64 strings) + * - does not require padding + * - understands base64url encoding: + * "-" instead of "+", + * "_" instead of "/", + * no padding + */ +export function base64Decode(base64Str) { + const table = getDecodeTable(); + // estimate byte size, not accounting for inner padding and whitespace + let es = (base64Str.length * 3) / 4; + if (base64Str[base64Str.length - 2] == "=") + es -= 2; + else if (base64Str[base64Str.length - 1] == "=") + es -= 1; + let bytes = new Uint8Array(es), bytePos = 0, // position in byte array + groupPos = 0, // position in base64 group + b, // current byte + p = 0; // previous byte + for (let i = 0; i < base64Str.length; i++) { + b = table[base64Str.charCodeAt(i)]; + if (b === undefined) { + switch (base64Str[i]) { + // @ts-ignore TS7029: Fallthrough case in switch -- ignore instead of expect-error for compiler settings without noFallthroughCasesInSwitch: true + case "=": + groupPos = 0; // reset state when padding found + case "\n": + case "\r": + case "\t": + case " ": + continue; // skip white-space, and padding + default: + throw Error("invalid base64 string"); + } + } + switch (groupPos) { + case 0: + p = b; + groupPos = 1; + break; + case 1: + bytes[bytePos++] = (p << 2) | ((b & 48) >> 4); + p = b; + groupPos = 2; + break; + case 2: + bytes[bytePos++] = ((p & 15) << 4) | ((b & 60) >> 2); + p = b; + groupPos = 3; + break; + case 3: + bytes[bytePos++] = ((p & 3) << 6) | b; + groupPos = 0; + break; + } + } + if (groupPos == 1) + throw Error("invalid base64 string"); + return bytes.subarray(0, bytePos); +} +/** + * Encode a byte array to a base64 string. + * + * By default, this function uses the standard base64 encoding with padding. + * + * To encode without padding, use encoding = "std_raw". + * + * To encode with the URL encoding, use encoding = "url", which replaces the + * characters +/ by their URL-safe counterparts -_, and omits padding. + */ +export function base64Encode(bytes, encoding = "std") { + const table = getEncodeTable(encoding); + const pad = encoding == "std"; + let base64 = "", groupPos = 0, // position in base64 group + b, // current byte + p = 0; // carry over from previous byte + for (let i = 0; i < bytes.length; i++) { + b = bytes[i]; + switch (groupPos) { + case 0: + base64 += table[b >> 2]; + p = (b & 3) << 4; + groupPos = 1; + break; + case 1: + base64 += table[p | (b >> 4)]; + p = (b & 15) << 2; + groupPos = 2; + break; + case 2: + base64 += table[p | (b >> 6)]; + base64 += table[b & 63]; + groupPos = 0; + break; + } + } + // add output padding + if (groupPos) { + base64 += table[p]; + if (pad) { + base64 += "="; + if (groupPos == 1) + base64 += "="; + } + } + return base64; +} +// lookup table from base64 character to byte +let encodeTableStd; +let encodeTableUrl; +// lookup table from base64 character *code* to byte because lookup by number is fast +let decodeTable; +function getEncodeTable(encoding) { + if (!encodeTableStd) { + encodeTableStd = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split(""); + encodeTableUrl = encodeTableStd.slice(0, -2).concat("-", "_"); + } + return encoding == "url" + ? // biome-ignore lint/style/noNonNullAssertion: TS fails to narrow down + encodeTableUrl + : encodeTableStd; +} +function getDecodeTable() { + if (!decodeTable) { + decodeTable = []; + const encodeTable = getEncodeTable("std"); + for (let i = 0; i < encodeTable.length; i++) + decodeTable[encodeTable[i].charCodeAt(0)] = i; + // support base64url variants + decodeTable["-".charCodeAt(0)] = encodeTable.indexOf("+"); + decodeTable["_".charCodeAt(0)] = encodeTable.indexOf("/"); + } + return decodeTable; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/binary-encoding.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/binary-encoding.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..58f1a08a1707d3fd66ada807328a5ee9e0ca6948 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/binary-encoding.d.ts @@ -0,0 +1,264 @@ +/** + * Protobuf binary format wire types. + * + * A wire type provides just enough information to find the length of the + * following value. + * + * See https://developers.google.com/protocol-buffers/docs/encoding#structure + */ +export declare enum WireType { + /** + * Used for int32, int64, uint32, uint64, sint32, sint64, bool, enum + */ + Varint = 0, + /** + * Used for fixed64, sfixed64, double. + * Always 8 bytes with little-endian byte order. + */ + Bit64 = 1, + /** + * Used for string, bytes, embedded messages, packed repeated fields + * + * Only repeated numeric types (types which use the varint, 32-bit, + * or 64-bit wire types) can be packed. In proto3, such fields are + * packed by default. + */ + LengthDelimited = 2, + /** + * Start of a tag-delimited aggregate, such as a proto2 group, or a message + * in editions with message_encoding = DELIMITED. + */ + StartGroup = 3, + /** + * End of a tag-delimited aggregate. + */ + EndGroup = 4, + /** + * Used for fixed32, sfixed32, float. + * Always 4 bytes with little-endian byte order. + */ + Bit32 = 5 +} +/** + * Maximum value for a 32-bit floating point value (Protobuf FLOAT). + */ +export declare const FLOAT32_MAX = 3.4028234663852886e+38; +/** + * Minimum value for a 32-bit floating point value (Protobuf FLOAT). + */ +export declare const FLOAT32_MIN = -3.4028234663852886e+38; +/** + * Maximum value for an unsigned 32-bit integer (Protobuf UINT32, FIXED32). + */ +export declare const UINT32_MAX = 4294967295; +/** + * Maximum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32). + */ +export declare const INT32_MAX = 2147483647; +/** + * Minimum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32). + */ +export declare const INT32_MIN = -2147483648; +export declare class BinaryWriter { + private readonly encodeUtf8; + /** + * We cannot allocate a buffer for the entire output + * because we don't know it's size. + * + * So we collect smaller chunks of known size and + * concat them later. + * + * Use `raw()` to push data to this array. It will flush + * `buf` first. + */ + private chunks; + /** + * A growing buffer for byte values. If you don't know + * the size of the data you are writing, push to this + * array. + */ + protected buf: number[]; + /** + * Previous fork states. + */ + private stack; + constructor(encodeUtf8?: (text: string) => Uint8Array); + /** + * Return all bytes written and reset this writer. + */ + finish(): Uint8Array; + /** + * Start a new fork for length-delimited data like a message + * or a packed repeated field. + * + * Must be joined later with `join()`. + */ + fork(): this; + /** + * Join the last fork. Write its length and bytes, then + * return to the previous state. + */ + join(): this; + /** + * Writes a tag (field number and wire type). + * + * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`. + * + * Generated code should compute the tag ahead of time and call `uint32()`. + */ + tag(fieldNo: number, type: WireType): this; + /** + * Write a chunk of raw bytes. + */ + raw(chunk: Uint8Array): this; + /** + * Write a `uint32` value, an unsigned 32 bit varint. + */ + uint32(value: number): this; + /** + * Write a `int32` value, a signed 32 bit varint. + */ + int32(value: number): this; + /** + * Write a `bool` value, a variant. + */ + bool(value: boolean): this; + /** + * Write a `bytes` value, length-delimited arbitrary data. + */ + bytes(value: Uint8Array): this; + /** + * Write a `string` value, length-delimited data converted to UTF-8 text. + */ + string(value: string): this; + /** + * Write a `float` value, 32-bit floating point number. + */ + float(value: number): this; + /** + * Write a `double` value, a 64-bit floating point number. + */ + double(value: number): this; + /** + * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer. + */ + fixed32(value: number): this; + /** + * Write a `sfixed32` value, a signed, fixed-length 32-bit integer. + */ + sfixed32(value: number): this; + /** + * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint. + */ + sint32(value: number): this; + /** + * Write a `fixed64` value, a signed, fixed-length 64-bit integer. + */ + sfixed64(value: string | number | bigint): this; + /** + * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer. + */ + fixed64(value: string | number | bigint): this; + /** + * Write a `int64` value, a signed 64-bit varint. + */ + int64(value: string | number | bigint): this; + /** + * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint. + */ + sint64(value: string | number | bigint): this; + /** + * Write a `uint64` value, an unsigned 64-bit varint. + */ + uint64(value: string | number | bigint): this; +} +export declare class BinaryReader { + private readonly decodeUtf8; + /** + * Current position. + */ + pos: number; + /** + * Number of bytes available in this reader. + */ + readonly len: number; + protected readonly buf: Uint8Array; + private readonly view; + constructor(buf: Uint8Array, decodeUtf8?: (bytes: Uint8Array) => string); + /** + * Reads a tag - field number and wire type. + */ + tag(): [number, WireType]; + /** + * Skip one element and return the skipped data. + * + * When skipping StartGroup, provide the tags field number to check for + * matching field number in the EndGroup tag. + */ + skip(wireType: WireType, fieldNo?: number): Uint8Array; + protected varint64: () => [number, number]; + /** + * Throws error if position in byte array is out of range. + */ + protected assertBounds(): void; + /** + * Read a `uint32` field, an unsigned 32 bit varint. + */ + uint32: () => number; + /** + * Read a `int32` field, a signed 32 bit varint. + */ + int32(): number; + /** + * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint. + */ + sint32(): number; + /** + * Read a `int64` field, a signed 64-bit varint. + */ + int64(): bigint | string; + /** + * Read a `uint64` field, an unsigned 64-bit varint. + */ + uint64(): bigint | string; + /** + * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint. + */ + sint64(): bigint | string; + /** + * Read a `bool` field, a variant. + */ + bool(): boolean; + /** + * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer. + */ + fixed32(): number; + /** + * Read a `sfixed32` field, a signed, fixed-length 32-bit integer. + */ + sfixed32(): number; + /** + * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer. + */ + fixed64(): bigint | string; + /** + * Read a `fixed64` field, a signed, fixed-length 64-bit integer. + */ + sfixed64(): bigint | string; + /** + * Read a `float` field, 32-bit floating point number. + */ + float(): number; + /** + * Read a `double` field, a 64-bit floating point number. + */ + double(): number; + /** + * Read a `bytes` field, length-delimited arbitrary data. + */ + bytes(): Uint8Array; + /** + * Read a `string` field, length-delimited data converted to UTF-8 text. + */ + string(): string; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/binary-encoding.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/binary-encoding.js new file mode 100644 index 0000000000000000000000000000000000000000..4862dfa0f938fbd38e9ca8c7d842774d76aefcb0 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/binary-encoding.js @@ -0,0 +1,510 @@ +// Copyright 2021-2025 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. +import { varint32read, varint32write, varint64read, varint64write, } from "./varint.js"; +import { protoInt64 } from "../proto-int64.js"; +import { getTextEncoding } from "./text-encoding.js"; +/** + * Protobuf binary format wire types. + * + * A wire type provides just enough information to find the length of the + * following value. + * + * See https://developers.google.com/protocol-buffers/docs/encoding#structure + */ +export var WireType; +(function (WireType) { + /** + * Used for int32, int64, uint32, uint64, sint32, sint64, bool, enum + */ + WireType[WireType["Varint"] = 0] = "Varint"; + /** + * Used for fixed64, sfixed64, double. + * Always 8 bytes with little-endian byte order. + */ + WireType[WireType["Bit64"] = 1] = "Bit64"; + /** + * Used for string, bytes, embedded messages, packed repeated fields + * + * Only repeated numeric types (types which use the varint, 32-bit, + * or 64-bit wire types) can be packed. In proto3, such fields are + * packed by default. + */ + WireType[WireType["LengthDelimited"] = 2] = "LengthDelimited"; + /** + * Start of a tag-delimited aggregate, such as a proto2 group, or a message + * in editions with message_encoding = DELIMITED. + */ + WireType[WireType["StartGroup"] = 3] = "StartGroup"; + /** + * End of a tag-delimited aggregate. + */ + WireType[WireType["EndGroup"] = 4] = "EndGroup"; + /** + * Used for fixed32, sfixed32, float. + * Always 4 bytes with little-endian byte order. + */ + WireType[WireType["Bit32"] = 5] = "Bit32"; +})(WireType || (WireType = {})); +/** + * Maximum value for a 32-bit floating point value (Protobuf FLOAT). + */ +export const FLOAT32_MAX = 3.4028234663852886e38; +/** + * Minimum value for a 32-bit floating point value (Protobuf FLOAT). + */ +export const FLOAT32_MIN = -3.4028234663852886e38; +/** + * Maximum value for an unsigned 32-bit integer (Protobuf UINT32, FIXED32). + */ +export const UINT32_MAX = 0xffffffff; +/** + * Maximum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32). + */ +export const INT32_MAX = 0x7fffffff; +/** + * Minimum value for a signed 32-bit integer (Protobuf INT32, SFIXED32, SINT32). + */ +export const INT32_MIN = -0x80000000; +export class BinaryWriter { + constructor(encodeUtf8 = getTextEncoding().encodeUtf8) { + this.encodeUtf8 = encodeUtf8; + /** + * Previous fork states. + */ + this.stack = []; + this.chunks = []; + this.buf = []; + } + /** + * Return all bytes written and reset this writer. + */ + finish() { + if (this.buf.length) { + this.chunks.push(new Uint8Array(this.buf)); // flush the buffer + this.buf = []; + } + let len = 0; + for (let i = 0; i < this.chunks.length; i++) + len += this.chunks[i].length; + let bytes = new Uint8Array(len); + let offset = 0; + for (let i = 0; i < this.chunks.length; i++) { + bytes.set(this.chunks[i], offset); + offset += this.chunks[i].length; + } + this.chunks = []; + return bytes; + } + /** + * Start a new fork for length-delimited data like a message + * or a packed repeated field. + * + * Must be joined later with `join()`. + */ + fork() { + this.stack.push({ chunks: this.chunks, buf: this.buf }); + this.chunks = []; + this.buf = []; + return this; + } + /** + * Join the last fork. Write its length and bytes, then + * return to the previous state. + */ + join() { + // get chunk of fork + let chunk = this.finish(); + // restore previous state + let prev = this.stack.pop(); + if (!prev) + throw new Error("invalid state, fork stack empty"); + this.chunks = prev.chunks; + this.buf = prev.buf; + // write length of chunk as varint + this.uint32(chunk.byteLength); + return this.raw(chunk); + } + /** + * Writes a tag (field number and wire type). + * + * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`. + * + * Generated code should compute the tag ahead of time and call `uint32()`. + */ + tag(fieldNo, type) { + return this.uint32(((fieldNo << 3) | type) >>> 0); + } + /** + * Write a chunk of raw bytes. + */ + raw(chunk) { + if (this.buf.length) { + this.chunks.push(new Uint8Array(this.buf)); + this.buf = []; + } + this.chunks.push(chunk); + return this; + } + /** + * Write a `uint32` value, an unsigned 32 bit varint. + */ + uint32(value) { + assertUInt32(value); + // write value as varint 32, inlined for speed + while (value > 0x7f) { + this.buf.push((value & 0x7f) | 0x80); + value = value >>> 7; + } + this.buf.push(value); + return this; + } + /** + * Write a `int32` value, a signed 32 bit varint. + */ + int32(value) { + assertInt32(value); + varint32write(value, this.buf); + return this; + } + /** + * Write a `bool` value, a variant. + */ + bool(value) { + this.buf.push(value ? 1 : 0); + return this; + } + /** + * Write a `bytes` value, length-delimited arbitrary data. + */ + bytes(value) { + this.uint32(value.byteLength); // write length of chunk as varint + return this.raw(value); + } + /** + * Write a `string` value, length-delimited data converted to UTF-8 text. + */ + string(value) { + let chunk = this.encodeUtf8(value); + this.uint32(chunk.byteLength); // write length of chunk as varint + return this.raw(chunk); + } + /** + * Write a `float` value, 32-bit floating point number. + */ + float(value) { + assertFloat32(value); + let chunk = new Uint8Array(4); + new DataView(chunk.buffer).setFloat32(0, value, true); + return this.raw(chunk); + } + /** + * Write a `double` value, a 64-bit floating point number. + */ + double(value) { + let chunk = new Uint8Array(8); + new DataView(chunk.buffer).setFloat64(0, value, true); + return this.raw(chunk); + } + /** + * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer. + */ + fixed32(value) { + assertUInt32(value); + let chunk = new Uint8Array(4); + new DataView(chunk.buffer).setUint32(0, value, true); + return this.raw(chunk); + } + /** + * Write a `sfixed32` value, a signed, fixed-length 32-bit integer. + */ + sfixed32(value) { + assertInt32(value); + let chunk = new Uint8Array(4); + new DataView(chunk.buffer).setInt32(0, value, true); + return this.raw(chunk); + } + /** + * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint. + */ + sint32(value) { + assertInt32(value); + // zigzag encode + value = ((value << 1) ^ (value >> 31)) >>> 0; + varint32write(value, this.buf); + return this; + } + /** + * Write a `fixed64` value, a signed, fixed-length 64-bit integer. + */ + sfixed64(value) { + let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = protoInt64.enc(value); + view.setInt32(0, tc.lo, true); + view.setInt32(4, tc.hi, true); + return this.raw(chunk); + } + /** + * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer. + */ + fixed64(value) { + let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = protoInt64.uEnc(value); + view.setInt32(0, tc.lo, true); + view.setInt32(4, tc.hi, true); + return this.raw(chunk); + } + /** + * Write a `int64` value, a signed 64-bit varint. + */ + int64(value) { + let tc = protoInt64.enc(value); + varint64write(tc.lo, tc.hi, this.buf); + return this; + } + /** + * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint. + */ + sint64(value) { + const tc = protoInt64.enc(value), + // zigzag encode + sign = tc.hi >> 31, lo = (tc.lo << 1) ^ sign, hi = ((tc.hi << 1) | (tc.lo >>> 31)) ^ sign; + varint64write(lo, hi, this.buf); + return this; + } + /** + * Write a `uint64` value, an unsigned 64-bit varint. + */ + uint64(value) { + const tc = protoInt64.uEnc(value); + varint64write(tc.lo, tc.hi, this.buf); + return this; + } +} +export class BinaryReader { + constructor(buf, decodeUtf8 = getTextEncoding().decodeUtf8) { + this.decodeUtf8 = decodeUtf8; + this.varint64 = varint64read; // dirty cast for `this` + /** + * Read a `uint32` field, an unsigned 32 bit varint. + */ + this.uint32 = varint32read; + this.buf = buf; + this.len = buf.length; + this.pos = 0; + this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength); + } + /** + * Reads a tag - field number and wire type. + */ + tag() { + let tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7; + if (fieldNo <= 0 || wireType < 0 || wireType > 5) + throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType); + return [fieldNo, wireType]; + } + /** + * Skip one element and return the skipped data. + * + * When skipping StartGroup, provide the tags field number to check for + * matching field number in the EndGroup tag. + */ + skip(wireType, fieldNo) { + let start = this.pos; + switch (wireType) { + case WireType.Varint: + while (this.buf[this.pos++] & 0x80) { + // ignore + } + break; + // @ts-ignore TS7029: Fallthrough case in switch -- ignore instead of expect-error for compiler settings without noFallthroughCasesInSwitch: true + case WireType.Bit64: + this.pos += 4; + case WireType.Bit32: + this.pos += 4; + break; + case WireType.LengthDelimited: + let len = this.uint32(); + this.pos += len; + break; + case WireType.StartGroup: + for (;;) { + const [fn, wt] = this.tag(); + if (wt === WireType.EndGroup) { + if (fieldNo !== undefined && fn !== fieldNo) { + throw new Error("invalid end group tag"); + } + break; + } + this.skip(wt, fn); + } + break; + default: + throw new Error("cant skip wire type " + wireType); + } + this.assertBounds(); + return this.buf.subarray(start, this.pos); + } + /** + * Throws error if position in byte array is out of range. + */ + assertBounds() { + if (this.pos > this.len) + throw new RangeError("premature EOF"); + } + /** + * Read a `int32` field, a signed 32 bit varint. + */ + int32() { + return this.uint32() | 0; + } + /** + * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint. + */ + sint32() { + let zze = this.uint32(); + // decode zigzag + return (zze >>> 1) ^ -(zze & 1); + } + /** + * Read a `int64` field, a signed 64-bit varint. + */ + int64() { + return protoInt64.dec(...this.varint64()); + } + /** + * Read a `uint64` field, an unsigned 64-bit varint. + */ + uint64() { + return protoInt64.uDec(...this.varint64()); + } + /** + * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint. + */ + sint64() { + let [lo, hi] = this.varint64(); + // decode zig zag + let s = -(lo & 1); + lo = ((lo >>> 1) | ((hi & 1) << 31)) ^ s; + hi = (hi >>> 1) ^ s; + return protoInt64.dec(lo, hi); + } + /** + * Read a `bool` field, a variant. + */ + bool() { + let [lo, hi] = this.varint64(); + return lo !== 0 || hi !== 0; + } + /** + * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer. + */ + fixed32() { + // biome-ignore lint/suspicious/noAssignInExpressions: no + return this.view.getUint32((this.pos += 4) - 4, true); + } + /** + * Read a `sfixed32` field, a signed, fixed-length 32-bit integer. + */ + sfixed32() { + // biome-ignore lint/suspicious/noAssignInExpressions: no + return this.view.getInt32((this.pos += 4) - 4, true); + } + /** + * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer. + */ + fixed64() { + return protoInt64.uDec(this.sfixed32(), this.sfixed32()); + } + /** + * Read a `fixed64` field, a signed, fixed-length 64-bit integer. + */ + sfixed64() { + return protoInt64.dec(this.sfixed32(), this.sfixed32()); + } + /** + * Read a `float` field, 32-bit floating point number. + */ + float() { + // biome-ignore lint/suspicious/noAssignInExpressions: no + return this.view.getFloat32((this.pos += 4) - 4, true); + } + /** + * Read a `double` field, a 64-bit floating point number. + */ + double() { + // biome-ignore lint/suspicious/noAssignInExpressions: no + return this.view.getFloat64((this.pos += 8) - 8, true); + } + /** + * Read a `bytes` field, length-delimited arbitrary data. + */ + bytes() { + let len = this.uint32(), start = this.pos; + this.pos += len; + this.assertBounds(); + return this.buf.subarray(start, start + len); + } + /** + * Read a `string` field, length-delimited data converted to UTF-8 text. + */ + string() { + return this.decodeUtf8(this.bytes()); + } +} +/** + * Assert a valid signed protobuf 32-bit integer as a number or string. + */ +function assertInt32(arg) { + if (typeof arg == "string") { + arg = Number(arg); + } + else if (typeof arg != "number") { + throw new Error("invalid int32: " + typeof arg); + } + if (!Number.isInteger(arg) || + arg > INT32_MAX || + arg < INT32_MIN) + throw new Error("invalid int32: " + arg); +} +/** + * Assert a valid unsigned protobuf 32-bit integer as a number or string. + */ +function assertUInt32(arg) { + if (typeof arg == "string") { + arg = Number(arg); + } + else if (typeof arg != "number") { + throw new Error("invalid uint32: " + typeof arg); + } + if (!Number.isInteger(arg) || + arg > UINT32_MAX || + arg < 0) + throw new Error("invalid uint32: " + arg); +} +/** + * Assert a valid protobuf float value as a number or string. + */ +function assertFloat32(arg) { + if (typeof arg == "string") { + const o = arg; + arg = Number(arg); + if (Number.isNaN(arg) && o !== "NaN") { + throw new Error("invalid float32: " + o); + } + } + else if (typeof arg != "number") { + throw new Error("invalid float32: " + typeof arg); + } + if (Number.isFinite(arg) && + (arg > FLOAT32_MAX || arg < FLOAT32_MIN)) + throw new Error("invalid float32: " + arg); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/index.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8630d1f3e023def8743bb0d3094182beefffa09f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/index.d.ts @@ -0,0 +1,5 @@ +export * from "./binary-encoding.js"; +export * from "./base64-encoding.js"; +export * from "./text-encoding.js"; +export * from "./text-format.js"; +export * from "./size-delimited.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/index.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/index.js new file mode 100644 index 0000000000000000000000000000000000000000..ed27ce74360e79c8cbc881a775a441e259d60a28 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/index.js @@ -0,0 +1,18 @@ +// Copyright 2021-2025 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. +export * from "./binary-encoding.js"; +export * from "./base64-encoding.js"; +export * from "./text-encoding.js"; +export * from "./text-format.js"; +export * from "./size-delimited.js"; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/size-delimited.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/size-delimited.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..02949899c60bc27476542bad5dd2049877c33ad2 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/size-delimited.d.ts @@ -0,0 +1,51 @@ +import type { DescMessage } from "../descriptors.js"; +import type { BinaryWriteOptions } from "../to-binary.js"; +import type { MessageShape } from "../types.js"; +import type { BinaryReadOptions } from "../from-binary.js"; +/** + * Serialize a message, prefixing it with its size. + * + * A size-delimited message is a varint size in bytes, followed by exactly + * that many bytes of a message serialized with the binary format. + * + * This size-delimited format is compatible with other implementations. + * For details, see https://github.com/protocolbuffers/protobuf/issues/10229 + */ +export declare function sizeDelimitedEncode(messageDesc: Desc, message: MessageShape, options?: BinaryWriteOptions): Uint8Array; +/** + * Parse a stream of size-delimited messages. + * + * A size-delimited message is a varint size in bytes, followed by exactly + * that many bytes of a message serialized with the binary format. + * + * This size-delimited format is compatible with other implementations. + * For details, see https://github.com/protocolbuffers/protobuf/issues/10229 + */ +export declare function sizeDelimitedDecodeStream(messageDesc: Desc, iterable: AsyncIterable, options?: BinaryReadOptions): AsyncIterableIterator>; +/** + * Decodes the size from the given size-delimited message, which may be + * incomplete. + * + * Returns an object with the following properties: + * - size: The size of the delimited message in bytes + * - offset: The offset in the given byte array where the message starts + * - eof: true + * + * If the size-delimited data does not include all bytes of the varint size, + * the following object is returned: + * - size: null + * - offset: null + * - eof: false + * + * This function can be used to implement parsing of size-delimited messages + * from a stream. + */ +export declare function sizeDelimitedPeek(data: Uint8Array): { + readonly eof: false; + readonly size: number; + readonly offset: number; +} | { + readonly eof: true; + readonly size: null; + readonly offset: null; +}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/size-delimited.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/size-delimited.js new file mode 100644 index 0000000000000000000000000000000000000000..3bf89ca1b585c73dfbb1c4794df6705606df0edb --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/size-delimited.js @@ -0,0 +1,148 @@ +// Copyright 2021-2025 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. +var __asyncValues = (this && this.__asyncValues) || function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); + function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } + function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } +}; +var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); } +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), i, q = []; + return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i; + function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; } + function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } + function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } +}; +import { toBinary } from "../to-binary.js"; +import { BinaryReader, BinaryWriter } from "./binary-encoding.js"; +import { fromBinary } from "../from-binary.js"; +/** + * Serialize a message, prefixing it with its size. + * + * A size-delimited message is a varint size in bytes, followed by exactly + * that many bytes of a message serialized with the binary format. + * + * This size-delimited format is compatible with other implementations. + * For details, see https://github.com/protocolbuffers/protobuf/issues/10229 + */ +export function sizeDelimitedEncode(messageDesc, message, options) { + const writer = new BinaryWriter(); + writer.bytes(toBinary(messageDesc, message, options)); + return writer.finish(); +} +/** + * Parse a stream of size-delimited messages. + * + * A size-delimited message is a varint size in bytes, followed by exactly + * that many bytes of a message serialized with the binary format. + * + * This size-delimited format is compatible with other implementations. + * For details, see https://github.com/protocolbuffers/protobuf/issues/10229 + */ +export function sizeDelimitedDecodeStream(messageDesc, iterable, options) { + return __asyncGenerator(this, arguments, function* sizeDelimitedDecodeStream_1() { + var _a, e_1, _b, _c; + // append chunk to buffer, returning updated buffer + function append(buffer, chunk) { + const n = new Uint8Array(buffer.byteLength + chunk.byteLength); + n.set(buffer); + n.set(chunk, buffer.length); + return n; + } + let buffer = new Uint8Array(0); + try { + for (var _d = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = yield __await(iterable_1.next()), _a = iterable_1_1.done, !_a; _d = true) { + _c = iterable_1_1.value; + _d = false; + const chunk = _c; + buffer = append(buffer, chunk); + for (;;) { + const size = sizeDelimitedPeek(buffer); + if (size.eof) { + // size is incomplete, buffer more data + break; + } + if (size.offset + size.size > buffer.byteLength) { + // message is incomplete, buffer more data + break; + } + yield yield __await(fromBinary(messageDesc, buffer.subarray(size.offset, size.offset + size.size), options)); + buffer = buffer.subarray(size.offset + size.size); + } + } + } + catch (e_1_1) { e_1 = { error: e_1_1 }; } + finally { + try { + if (!_d && !_a && (_b = iterable_1.return)) yield __await(_b.call(iterable_1)); + } + finally { if (e_1) throw e_1.error; } + } + if (buffer.byteLength > 0) { + throw new Error("incomplete data"); + } + }); +} +/** + * Decodes the size from the given size-delimited message, which may be + * incomplete. + * + * Returns an object with the following properties: + * - size: The size of the delimited message in bytes + * - offset: The offset in the given byte array where the message starts + * - eof: true + * + * If the size-delimited data does not include all bytes of the varint size, + * the following object is returned: + * - size: null + * - offset: null + * - eof: false + * + * This function can be used to implement parsing of size-delimited messages + * from a stream. + */ +export function sizeDelimitedPeek(data) { + const sizeEof = { eof: true, size: null, offset: null }; + for (let i = 0; i < 10; i++) { + if (i > data.byteLength) { + return sizeEof; + } + if ((data[i] & 0x80) == 0) { + const reader = new BinaryReader(data); + let size; + try { + size = reader.uint32(); + } + catch (e) { + if (e instanceof RangeError) { + return sizeEof; + } + throw e; + } + return { + eof: false, + size, + offset: reader.pos, + }; + } + } + throw new Error("invalid varint"); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/text-encoding.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/text-encoding.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..17761ea742a18ab1b476c7bd9fcad11bcdc3db3c --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/text-encoding.d.ts @@ -0,0 +1,26 @@ +interface TextEncoding { + /** + * Verify that the given text is valid UTF-8. + */ + checkUtf8: (text: string) => boolean; + /** + * Encode UTF-8 text to binary. + */ + encodeUtf8: (text: string) => Uint8Array; + /** + * Decode UTF-8 text from binary. + */ + decodeUtf8: (bytes: Uint8Array) => string; +} +/** + * Protobuf-ES requires the Text Encoding API to convert UTF-8 from and to + * binary. This WHATWG API is widely available, but it is not part of the + * ECMAScript standard. On runtimes where it is not available, use this + * function to provide your own implementation. + * + * Note that the Text Encoding API does not provide a way to validate UTF-8. + * Our implementation falls back to use encodeURIComponent(). + */ +export declare function configureTextEncoding(textEncoding: TextEncoding): void; +export declare function getTextEncoding(): TextEncoding; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/text-encoding.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/text-encoding.js new file mode 100644 index 0000000000000000000000000000000000000000..8cd9b24711044c46936b470c922be9fa11b9cae6 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/text-encoding.js @@ -0,0 +1,50 @@ +// Copyright 2021-2025 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. +const symbol = Symbol.for("@bufbuild/protobuf/text-encoding"); +/** + * Protobuf-ES requires the Text Encoding API to convert UTF-8 from and to + * binary. This WHATWG API is widely available, but it is not part of the + * ECMAScript standard. On runtimes where it is not available, use this + * function to provide your own implementation. + * + * Note that the Text Encoding API does not provide a way to validate UTF-8. + * Our implementation falls back to use encodeURIComponent(). + */ +export function configureTextEncoding(textEncoding) { + globalThis[symbol] = textEncoding; +} +export function getTextEncoding() { + if (globalThis[symbol] == undefined) { + const te = new globalThis.TextEncoder(); + const td = new globalThis.TextDecoder(); + globalThis[symbol] = { + encodeUtf8(text) { + return te.encode(text); + }, + decodeUtf8(bytes) { + return td.decode(bytes); + }, + checkUtf8(text) { + try { + encodeURIComponent(text); + return true; + } + catch (_) { + return false; + } + }, + }; + } + return globalThis[symbol]; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/text-format.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/text-format.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..06bdbdd9590efb911a46963759d532957405a6cc --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/text-format.d.ts @@ -0,0 +1,13 @@ +import { type DescEnum, ScalarType } from "../descriptors.js"; +/** + * Parse an enum value from the Protobuf text format. + * + * @private + */ +export declare function parseTextFormatEnumValue(descEnum: DescEnum, value: string): number; +/** + * Parse a scalar value from the Protobuf text format. + * + * @private + */ +export declare function parseTextFormatScalarValue(type: ScalarType, value: string): number | boolean | string | bigint | Uint8Array; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/text-format.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/text-format.js new file mode 100644 index 0000000000000000000000000000000000000000..7d0dc1b8a3c2484face44e0acf719413937a5c7d --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/text-format.js @@ -0,0 +1,195 @@ +// Copyright 2021-2025 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. +import { ScalarType } from "../descriptors.js"; +import { protoInt64 } from "../proto-int64.js"; +/** + * Parse an enum value from the Protobuf text format. + * + * @private + */ +export function parseTextFormatEnumValue(descEnum, value) { + const enumValue = descEnum.values.find((v) => v.name === value); + if (!enumValue) { + throw new Error(`cannot parse ${descEnum} default value: ${value}`); + } + return enumValue.number; +} +/** + * Parse a scalar value from the Protobuf text format. + * + * @private + */ +export function parseTextFormatScalarValue(type, value) { + switch (type) { + case ScalarType.STRING: + return value; + case ScalarType.BYTES: { + const u = unescapeBytesDefaultValue(value); + if (u === false) { + throw new Error(`cannot parse ${ScalarType[type]} default value: ${value}`); + } + return u; + } + case ScalarType.INT64: + case ScalarType.SFIXED64: + case ScalarType.SINT64: + return protoInt64.parse(value); + case ScalarType.UINT64: + case ScalarType.FIXED64: + return protoInt64.uParse(value); + case ScalarType.DOUBLE: + case ScalarType.FLOAT: + switch (value) { + case "inf": + return Number.POSITIVE_INFINITY; + case "-inf": + return Number.NEGATIVE_INFINITY; + case "nan": + return Number.NaN; + default: + return parseFloat(value); + } + case ScalarType.BOOL: + return value === "true"; + case ScalarType.INT32: + case ScalarType.UINT32: + case ScalarType.SINT32: + case ScalarType.FIXED32: + case ScalarType.SFIXED32: + return parseInt(value, 10); + } +} +/** + * Parses a text-encoded default value (proto2) of a BYTES field. + */ +function unescapeBytesDefaultValue(str) { + const b = []; + const input = { + tail: str, + c: "", + next() { + if (this.tail.length == 0) { + return false; + } + this.c = this.tail[0]; + this.tail = this.tail.substring(1); + return true; + }, + take(n) { + if (this.tail.length >= n) { + const r = this.tail.substring(0, n); + this.tail = this.tail.substring(n); + return r; + } + return false; + }, + }; + while (input.next()) { + switch (input.c) { + case "\\": + if (input.next()) { + switch (input.c) { + case "\\": + b.push(input.c.charCodeAt(0)); + break; + case "b": + b.push(0x08); + break; + case "f": + b.push(0x0c); + break; + case "n": + b.push(0x0a); + break; + case "r": + b.push(0x0d); + break; + case "t": + b.push(0x09); + break; + case "v": + b.push(0x0b); + break; + case "0": + case "1": + case "2": + case "3": + case "4": + case "5": + case "6": + case "7": { + const s = input.c; + const t = input.take(2); + if (t === false) { + return false; + } + const n = parseInt(s + t, 8); + if (Number.isNaN(n)) { + return false; + } + b.push(n); + break; + } + case "x": { + const s = input.c; + const t = input.take(2); + if (t === false) { + return false; + } + const n = parseInt(s + t, 16); + if (Number.isNaN(n)) { + return false; + } + b.push(n); + break; + } + case "u": { + const s = input.c; + const t = input.take(4); + if (t === false) { + return false; + } + const n = parseInt(s + t, 16); + if (Number.isNaN(n)) { + return false; + } + const chunk = new Uint8Array(4); + const view = new DataView(chunk.buffer); + view.setInt32(0, n, true); + b.push(chunk[0], chunk[1], chunk[2], chunk[3]); + break; + } + case "U": { + const s = input.c; + const t = input.take(8); + if (t === false) { + return false; + } + const tc = protoInt64.uEnc(s + t); + const chunk = new Uint8Array(8); + const view = new DataView(chunk.buffer); + view.setInt32(0, tc.lo, true); + view.setInt32(4, tc.hi, true); + b.push(chunk[0], chunk[1], chunk[2], chunk[3], chunk[4], chunk[5], chunk[6], chunk[7]); + break; + } + } + } + break; + default: + b.push(input.c.charCodeAt(0)); + } + } + return new Uint8Array(b); +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/varint.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/varint.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b45ef94e9310d528c34c52f6c1bb6ebbdf951a5f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/varint.d.ts @@ -0,0 +1,70 @@ +/** + * Read a 64 bit varint as two JS numbers. + * + * Returns tuple: + * [0]: low bits + * [1]: high bits + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175 + */ +export declare function varint64read(this: T): [number, number]; +/** + * Write a 64 bit varint, given as two JS numbers, to the given bytes array. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344 + */ +export declare function varint64write(lo: number, hi: number, bytes: number[]): void; +/** + * Parse decimal string of 64 bit integer value as two JS numbers. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10 + */ +export declare function int64FromString(dec: string): { + lo: number; + hi: number; +}; +/** + * Losslessly converts a 64-bit signed integer in 32:32 split representation + * into a decimal string. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10 + */ +export declare function int64ToString(lo: number, hi: number): string; +/** + * Losslessly converts a 64-bit unsigned integer in 32:32 split representation + * into a decimal string. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10 + */ +export declare function uInt64ToString(lo: number, hi: number): string; +/** + * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)` + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144 + */ +export declare function varint32write(value: number, bytes: number[]): void; +/** + * Read an unsigned 32 bit varint. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220 + */ +export declare function varint32read(this: T): number; +type ReaderLike = { + buf: Uint8Array; + pos: number; + len: number; + assertBounds(): void; +}; +export {}; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/varint.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/varint.js new file mode 100644 index 0000000000000000000000000000000000000000..a333bc8fadf61c09772fece2d5cf833ff2a7e5af --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wire/varint.js @@ -0,0 +1,313 @@ +// Copyright 2008 Google Inc. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Code generated by the Protocol Buffer compiler is owned by the owner +// of the input file used when generating it. This code is not +// standalone and requires a support library to be linked with it. This +// support library is itself covered by the above license. +/** + * Read a 64 bit varint as two JS numbers. + * + * Returns tuple: + * [0]: low bits + * [1]: high bits + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175 + */ +export function varint64read() { + let lowBits = 0; + let highBits = 0; + for (let shift = 0; shift < 28; shift += 7) { + let b = this.buf[this.pos++]; + lowBits |= (b & 0x7f) << shift; + if ((b & 0x80) == 0) { + this.assertBounds(); + return [lowBits, highBits]; + } + } + let middleByte = this.buf[this.pos++]; + // last four bits of the first 32 bit number + lowBits |= (middleByte & 0x0f) << 28; + // 3 upper bits are part of the next 32 bit number + highBits = (middleByte & 0x70) >> 4; + if ((middleByte & 0x80) == 0) { + this.assertBounds(); + return [lowBits, highBits]; + } + for (let shift = 3; shift <= 31; shift += 7) { + let b = this.buf[this.pos++]; + highBits |= (b & 0x7f) << shift; + if ((b & 0x80) == 0) { + this.assertBounds(); + return [lowBits, highBits]; + } + } + throw new Error("invalid varint"); +} +/** + * Write a 64 bit varint, given as two JS numbers, to the given bytes array. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344 + */ +export function varint64write(lo, hi, bytes) { + for (let i = 0; i < 28; i = i + 7) { + const shift = lo >>> i; + const hasNext = !(shift >>> 7 == 0 && hi == 0); + const byte = (hasNext ? shift | 0x80 : shift) & 0xff; + bytes.push(byte); + if (!hasNext) { + return; + } + } + const splitBits = ((lo >>> 28) & 0x0f) | ((hi & 0x07) << 4); + const hasMoreBits = !(hi >> 3 == 0); + bytes.push((hasMoreBits ? splitBits | 0x80 : splitBits) & 0xff); + if (!hasMoreBits) { + return; + } + for (let i = 3; i < 31; i = i + 7) { + const shift = hi >>> i; + const hasNext = !(shift >>> 7 == 0); + const byte = (hasNext ? shift | 0x80 : shift) & 0xff; + bytes.push(byte); + if (!hasNext) { + return; + } + } + bytes.push((hi >>> 31) & 0x01); +} +// constants for binary math +const TWO_PWR_32_DBL = 0x100000000; +/** + * Parse decimal string of 64 bit integer value as two JS numbers. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10 + */ +export function int64FromString(dec) { + // Check for minus sign. + const minus = dec[0] === "-"; + if (minus) { + dec = dec.slice(1); + } + // Work 6 decimal digits at a time, acting like we're converting base 1e6 + // digits to binary. This is safe to do with floating point math because + // Number.isSafeInteger(ALL_32_BITS * 1e6) == true. + const base = 1e6; + let lowBits = 0; + let highBits = 0; + function add1e6digit(begin, end) { + // Note: Number('') is 0. + const digit1e6 = Number(dec.slice(begin, end)); + highBits *= base; + lowBits = lowBits * base + digit1e6; + // Carry bits from lowBits to + if (lowBits >= TWO_PWR_32_DBL) { + highBits = highBits + ((lowBits / TWO_PWR_32_DBL) | 0); + lowBits = lowBits % TWO_PWR_32_DBL; + } + } + add1e6digit(-24, -18); + add1e6digit(-18, -12); + add1e6digit(-12, -6); + add1e6digit(-6); + return minus ? negate(lowBits, highBits) : newBits(lowBits, highBits); +} +/** + * Losslessly converts a 64-bit signed integer in 32:32 split representation + * into a decimal string. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10 + */ +export function int64ToString(lo, hi) { + let bits = newBits(lo, hi); + // If we're treating the input as a signed value and the high bit is set, do + // a manual two's complement conversion before the decimal conversion. + const negative = bits.hi & 0x80000000; + if (negative) { + bits = negate(bits.lo, bits.hi); + } + const result = uInt64ToString(bits.lo, bits.hi); + return negative ? "-" + result : result; +} +/** + * Losslessly converts a 64-bit unsigned integer in 32:32 split representation + * into a decimal string. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10 + */ +export function uInt64ToString(lo, hi) { + ({ lo, hi } = toUnsigned(lo, hi)); + // Skip the expensive conversion if the number is small enough to use the + // built-in conversions. + // Number.MAX_SAFE_INTEGER = 0x001FFFFF FFFFFFFF, thus any number with + // highBits <= 0x1FFFFF can be safely expressed with a double and retain + // integer precision. + // Proven by: Number.isSafeInteger(0x1FFFFF * 2**32 + 0xFFFFFFFF) == true. + if (hi <= 0x1fffff) { + return String(TWO_PWR_32_DBL * hi + lo); + } + // What this code is doing is essentially converting the input number from + // base-2 to base-1e7, which allows us to represent the 64-bit range with + // only 3 (very large) digits. Those digits are then trivial to convert to + // a base-10 string. + // The magic numbers used here are - + // 2^24 = 16777216 = (1,6777216) in base-1e7. + // 2^48 = 281474976710656 = (2,8147497,6710656) in base-1e7. + // Split 32:32 representation into 16:24:24 representation so our + // intermediate digits don't overflow. + const low = lo & 0xffffff; + const mid = ((lo >>> 24) | (hi << 8)) & 0xffffff; + const high = (hi >> 16) & 0xffff; + // Assemble our three base-1e7 digits, ignoring carries. The maximum + // value in a digit at this step is representable as a 48-bit integer, which + // can be stored in a 64-bit floating point number. + let digitA = low + mid * 6777216 + high * 6710656; + let digitB = mid + high * 8147497; + let digitC = high * 2; + // Apply carries from A to B and from B to C. + const base = 10000000; + if (digitA >= base) { + digitB += Math.floor(digitA / base); + digitA %= base; + } + if (digitB >= base) { + digitC += Math.floor(digitB / base); + digitB %= base; + } + // If digitC is 0, then we should have returned in the trivial code path + // at the top for non-safe integers. Given this, we can assume both digitB + // and digitA need leading zeros. + return (digitC.toString() + + decimalFrom1e7WithLeadingZeros(digitB) + + decimalFrom1e7WithLeadingZeros(digitA)); +} +function toUnsigned(lo, hi) { + return { lo: lo >>> 0, hi: hi >>> 0 }; +} +function newBits(lo, hi) { + return { lo: lo | 0, hi: hi | 0 }; +} +/** + * Returns two's compliment negation of input. + * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Signed_32-bit_integers + */ +function negate(lowBits, highBits) { + highBits = ~highBits; + if (lowBits) { + lowBits = ~lowBits + 1; + } + else { + // If lowBits is 0, then bitwise-not is 0xFFFFFFFF, + // adding 1 to that, results in 0x100000000, which leaves + // the low bits 0x0 and simply adds one to the high bits. + highBits += 1; + } + return newBits(lowBits, highBits); +} +/** + * Returns decimal representation of digit1e7 with leading zeros. + */ +const decimalFrom1e7WithLeadingZeros = (digit1e7) => { + const partial = String(digit1e7); + return "0000000".slice(partial.length) + partial; +}; +/** + * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)` + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144 + */ +export function varint32write(value, bytes) { + if (value >= 0) { + // write value as varint 32 + while (value > 0x7f) { + bytes.push((value & 0x7f) | 0x80); + value = value >>> 7; + } + bytes.push(value); + } + else { + for (let i = 0; i < 9; i++) { + bytes.push((value & 127) | 128); + value = value >> 7; + } + bytes.push(1); + } +} +/** + * Read an unsigned 32 bit varint. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220 + */ +export function varint32read() { + let b = this.buf[this.pos++]; + let result = b & 0x7f; + if ((b & 0x80) == 0) { + this.assertBounds(); + return result; + } + b = this.buf[this.pos++]; + result |= (b & 0x7f) << 7; + if ((b & 0x80) == 0) { + this.assertBounds(); + return result; + } + b = this.buf[this.pos++]; + result |= (b & 0x7f) << 14; + if ((b & 0x80) == 0) { + this.assertBounds(); + return result; + } + b = this.buf[this.pos++]; + result |= (b & 0x7f) << 21; + if ((b & 0x80) == 0) { + this.assertBounds(); + return result; + } + // Extract only last 4 bits + b = this.buf[this.pos++]; + result |= (b & 0x0f) << 28; + for (let readBytes = 5; (b & 0x80) !== 0 && readBytes < 10; readBytes++) + b = this.buf[this.pos++]; + if ((b & 0x80) != 0) + throw new Error("invalid varint"); + this.assertBounds(); + // Result can have 32 bits, convert it to unsigned + return result >>> 0; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/any.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/any.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5d417814b34752cd5c37a0b945343e249bde3d3f --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/any.d.ts @@ -0,0 +1,38 @@ +import type { Message, MessageShape } from "../types.js"; +import type { Any } from "./gen/google/protobuf/any_pb.js"; +import type { DescMessage } from "../descriptors.js"; +import type { Registry } from "../registry.js"; +/** + * Creates a `google.protobuf.Any` from a message. + */ +export declare function anyPack(schema: Desc, message: MessageShape): Any; +/** + * Packs the message into the given any. + */ +export declare function anyPack(schema: Desc, message: MessageShape, into: Any): void; +/** + * Returns true if the Any contains the type given by schema. + */ +export declare function anyIs(any: Any, schema: DescMessage): boolean; +/** + * Returns true if the Any contains a message with the given typeName. + */ +export declare function anyIs(any: Any, typeName: string): boolean; +/** + * Unpacks the message the Any represents. + * + * Returns undefined if the Any is empty, or if packed type is not included + * in the given registry. + */ +export declare function anyUnpack(any: Any, registry: Registry): Message | undefined; +/** + * Unpacks the message the Any represents. + * + * Returns undefined if the Any is empty, or if it does not contain the type + * given by schema. + */ +export declare function anyUnpack(any: Any, schema: Desc): MessageShape | undefined; +/** + * Same as anyUnpack but unpacks into the target message. + */ +export declare function anyUnpackTo(any: Any, schema: Desc, message: MessageShape): MessageShape | undefined; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/any.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/any.js new file mode 100644 index 0000000000000000000000000000000000000000..c6b9b0ff1a6c558d513ee3efc6458edf7bef9299 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/any.js @@ -0,0 +1,69 @@ +// Copyright 2021-2025 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. +import { AnySchema } from "./gen/google/protobuf/any_pb.js"; +import { create } from "../create.js"; +import { toBinary } from "../to-binary.js"; +import { fromBinary, mergeFromBinary } from "../from-binary.js"; +export function anyPack(schema, message, into) { + let ret = false; + if (!into) { + into = create(AnySchema); + ret = true; + } + into.value = toBinary(schema, message); + into.typeUrl = typeNameToUrl(message.$typeName); + return ret ? into : undefined; +} +export function anyIs(any, descOrTypeName) { + if (any.typeUrl === "") { + return false; + } + const want = typeof descOrTypeName == "string" + ? descOrTypeName + : descOrTypeName.typeName; + const got = typeUrlToName(any.typeUrl); + return want === got; +} +export function anyUnpack(any, registryOrMessageDesc) { + if (any.typeUrl === "") { + return undefined; + } + const desc = registryOrMessageDesc.kind == "message" + ? registryOrMessageDesc + : registryOrMessageDesc.getMessage(typeUrlToName(any.typeUrl)); + if (!desc || !anyIs(any, desc)) { + return undefined; + } + return fromBinary(desc, any.value); +} +/** + * Same as anyUnpack but unpacks into the target message. + */ +export function anyUnpackTo(any, schema, message) { + if (!anyIs(any, schema)) { + return undefined; + } + return mergeFromBinary(schema, message, any.value); +} +function typeNameToUrl(name) { + return `type.googleapis.com/${name}`; +} +function typeUrlToName(url) { + const slash = url.lastIndexOf("/"); + const name = slash >= 0 ? url.substring(slash + 1) : url; + if (!name.length) { + throw new Error(`invalid type url: ${url}`); + } + return name; +} diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/any_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/any_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a61678ffd68cfc322d4753aca24470f239744062 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/any_pb.d.ts @@ -0,0 +1,238 @@ +import type { GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/any.proto. + */ +export declare const file_google_protobuf_any: GenFile; +/** + * `Any` contains an arbitrary serialized protocol buffer message along with a + * URL that describes the type of the serialized message. + * + * Protobuf library provides support to pack/unpack Any values in the form + * of utility functions or additional generated methods of the Any type. + * + * Example 1: Pack and unpack a message in C++. + * + * Foo foo = ...; + * Any any; + * any.PackFrom(foo); + * ... + * if (any.UnpackTo(&foo)) { + * ... + * } + * + * Example 2: Pack and unpack a message in Java. + * + * Foo foo = ...; + * Any any = Any.pack(foo); + * ... + * if (any.is(Foo.class)) { + * foo = any.unpack(Foo.class); + * } + * // or ... + * if (any.isSameTypeAs(Foo.getDefaultInstance())) { + * foo = any.unpack(Foo.getDefaultInstance()); + * } + * + * Example 3: Pack and unpack a message in Python. + * + * foo = Foo(...) + * any = Any() + * any.Pack(foo) + * ... + * if any.Is(Foo.DESCRIPTOR): + * any.Unpack(foo) + * ... + * + * Example 4: Pack and unpack a message in Go + * + * foo := &pb.Foo{...} + * any, err := anypb.New(foo) + * if err != nil { + * ... + * } + * ... + * foo := &pb.Foo{} + * if err := any.UnmarshalTo(foo); err != nil { + * ... + * } + * + * The pack methods provided by protobuf library will by default use + * 'type.googleapis.com/full.type.name' as the type URL and the unpack + * methods only use the fully qualified type name after the last '/' + * in the type URL, for example "foo.bar.com/x/y.z" will yield type + * name "y.z". + * + * JSON + * ==== + * The JSON representation of an `Any` value uses the regular + * representation of the deserialized, embedded message, with an + * additional field `@type` which contains the type URL. Example: + * + * package google.profile; + * message Person { + * string first_name = 1; + * string last_name = 2; + * } + * + * { + * "@type": "type.googleapis.com/google.profile.Person", + * "firstName": , + * "lastName": + * } + * + * If the embedded message type is well-known and has a custom JSON + * representation, that representation will be embedded adding a field + * `value` which holds the custom JSON in addition to the `@type` + * field. Example (for message [google.protobuf.Duration][]): + * + * { + * "@type": "type.googleapis.com/google.protobuf.Duration", + * "value": "1.212s" + * } + * + * + * @generated from message google.protobuf.Any + */ +export type Any = Message<"google.protobuf.Any"> & { + /** + * A URL/resource name that uniquely identifies the type of the serialized + * protocol buffer message. This string must contain at least + * one "/" character. The last segment of the URL's path must represent + * the fully qualified name of the type (as in + * `path/google.protobuf.Duration`). The name should be in a canonical form + * (e.g., leading "." is not accepted). + * + * In practice, teams usually precompile into the binary all types that they + * expect it to use in the context of Any. However, for URLs which use the + * scheme `http`, `https`, or no scheme, one can optionally set up a type + * server that maps type URLs to message definitions as follows: + * + * * If no scheme is provided, `https` is assumed. + * * An HTTP GET on the URL must yield a [google.protobuf.Type][] + * value in binary format, or produce an error. + * * Applications are allowed to cache lookup results based on the + * URL, or have them precompiled into a binary to avoid any + * lookup. Therefore, binary compatibility needs to be preserved + * on changes to types. (Use versioned type names to manage + * breaking changes.) + * + * Note: this functionality is not currently available in the official + * protobuf release, and it is not used for type URLs beginning with + * type.googleapis.com. As of May 2023, there are no widely used type server + * implementations and no plans to implement one. + * + * Schemes other than `http`, `https` (or the empty scheme) might be + * used with implementation specific semantics. + * + * + * @generated from field: string type_url = 1; + */ + typeUrl: string; + /** + * Must be a valid serialized protocol buffer of the above specified type. + * + * @generated from field: bytes value = 2; + */ + value: Uint8Array; +}; +/** + * `Any` contains an arbitrary serialized protocol buffer message along with a + * URL that describes the type of the serialized message. + * + * Protobuf library provides support to pack/unpack Any values in the form + * of utility functions or additional generated methods of the Any type. + * + * Example 1: Pack and unpack a message in C++. + * + * Foo foo = ...; + * Any any; + * any.PackFrom(foo); + * ... + * if (any.UnpackTo(&foo)) { + * ... + * } + * + * Example 2: Pack and unpack a message in Java. + * + * Foo foo = ...; + * Any any = Any.pack(foo); + * ... + * if (any.is(Foo.class)) { + * foo = any.unpack(Foo.class); + * } + * // or ... + * if (any.isSameTypeAs(Foo.getDefaultInstance())) { + * foo = any.unpack(Foo.getDefaultInstance()); + * } + * + * Example 3: Pack and unpack a message in Python. + * + * foo = Foo(...) + * any = Any() + * any.Pack(foo) + * ... + * if any.Is(Foo.DESCRIPTOR): + * any.Unpack(foo) + * ... + * + * Example 4: Pack and unpack a message in Go + * + * foo := &pb.Foo{...} + * any, err := anypb.New(foo) + * if err != nil { + * ... + * } + * ... + * foo := &pb.Foo{} + * if err := any.UnmarshalTo(foo); err != nil { + * ... + * } + * + * The pack methods provided by protobuf library will by default use + * 'type.googleapis.com/full.type.name' as the type URL and the unpack + * methods only use the fully qualified type name after the last '/' + * in the type URL, for example "foo.bar.com/x/y.z" will yield type + * name "y.z". + * + * JSON + * ==== + * The JSON representation of an `Any` value uses the regular + * representation of the deserialized, embedded message, with an + * additional field `@type` which contains the type URL. Example: + * + * package google.profile; + * message Person { + * string first_name = 1; + * string last_name = 2; + * } + * + * { + * "@type": "type.googleapis.com/google.profile.Person", + * "firstName": , + * "lastName": + * } + * + * If the embedded message type is well-known and has a custom JSON + * representation, that representation will be embedded adding a field + * `value` which holds the custom JSON in addition to the `@type` + * field. Example (for message [google.protobuf.Duration][]): + * + * { + * "@type": "type.googleapis.com/google.protobuf.Duration", + * "value": "1.212s" + * } + * + * + * @generated from message google.protobuf.Any + */ +export type AnyJson = { + "@type"?: string; +}; +/** + * Describes the message google.protobuf.Any. + * Use `create(AnySchema)` to create a new message. + */ +export declare const AnySchema: GenMessage; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/any_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/any_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..e24f97539e27d6e4dc9e0274d76b5646a92bf2ff --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/any_pb.js @@ -0,0 +1,24 @@ +// Copyright 2021-2025 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. +import { fileDesc } from "../../../../codegenv2/file.js"; +import { messageDesc } from "../../../../codegenv2/message.js"; +/** + * Describes the file google/protobuf/any.proto. + */ +export const file_google_protobuf_any = /*@__PURE__*/ fileDesc("Chlnb29nbGUvcHJvdG9idWYvYW55LnByb3RvEg9nb29nbGUucHJvdG9idWYiJgoDQW55EhAKCHR5cGVfdXJsGAEgASgJEg0KBXZhbHVlGAIgASgMQnYKE2NvbS5nb29nbGUucHJvdG9idWZCCEFueVByb3RvUAFaLGdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL2FueXBiogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxLbm93blR5cGVzYgZwcm90bzM"); +/** + * Describes the message google.protobuf.Any. + * Use `create(AnySchema)` to create a new message. + */ +export const AnySchema = /*@__PURE__*/ messageDesc(file_google_protobuf_any, 0); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/api_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/api_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4cfad435f1b4da0d042c60420aca4be2229bfd65 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/api_pb.d.ts @@ -0,0 +1,477 @@ +import type { GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { SourceContext, SourceContextJson } from "./source_context_pb.js"; +import type { Option, OptionJson, Syntax, SyntaxJson } from "./type_pb.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/api.proto. + */ +export declare const file_google_protobuf_api: GenFile; +/** + * Api is a light-weight descriptor for an API Interface. + * + * Interfaces are also described as "protocol buffer services" in some contexts, + * such as by the "service" keyword in a .proto file, but they are different + * from API Services, which represent a concrete implementation of an interface + * as opposed to simply a description of methods and bindings. They are also + * sometimes simply referred to as "APIs" in other contexts, such as the name of + * this message itself. See https://cloud.google.com/apis/design/glossary for + * detailed terminology. + * + * @generated from message google.protobuf.Api + */ +export type Api = Message<"google.protobuf.Api"> & { + /** + * The fully qualified name of this interface, including package name + * followed by the interface's simple name. + * + * @generated from field: string name = 1; + */ + name: string; + /** + * The methods of this interface, in unspecified order. + * + * @generated from field: repeated google.protobuf.Method methods = 2; + */ + methods: Method[]; + /** + * Any metadata attached to the interface. + * + * @generated from field: repeated google.protobuf.Option options = 3; + */ + options: Option[]; + /** + * A version string for this interface. If specified, must have the form + * `major-version.minor-version`, as in `1.10`. If the minor version is + * omitted, it defaults to zero. If the entire version field is empty, the + * major version is derived from the package name, as outlined below. If the + * field is not empty, the version in the package name will be verified to be + * consistent with what is provided here. + * + * The versioning schema uses [semantic + * versioning](http://semver.org) where the major version number + * indicates a breaking change and the minor version an additive, + * non-breaking change. Both version numbers are signals to users + * what to expect from different versions, and should be carefully + * chosen based on the product plan. + * + * The major version is also reflected in the package name of the + * interface, which must end in `v`, as in + * `google.feature.v1`. For major versions 0 and 1, the suffix can + * be omitted. Zero major versions must only be used for + * experimental, non-GA interfaces. + * + * + * @generated from field: string version = 4; + */ + version: string; + /** + * Source context for the protocol buffer service represented by this + * message. + * + * @generated from field: google.protobuf.SourceContext source_context = 5; + */ + sourceContext?: SourceContext; + /** + * Included interfaces. See [Mixin][]. + * + * @generated from field: repeated google.protobuf.Mixin mixins = 6; + */ + mixins: Mixin[]; + /** + * The source syntax of the service. + * + * @generated from field: google.protobuf.Syntax syntax = 7; + */ + syntax: Syntax; +}; +/** + * Api is a light-weight descriptor for an API Interface. + * + * Interfaces are also described as "protocol buffer services" in some contexts, + * such as by the "service" keyword in a .proto file, but they are different + * from API Services, which represent a concrete implementation of an interface + * as opposed to simply a description of methods and bindings. They are also + * sometimes simply referred to as "APIs" in other contexts, such as the name of + * this message itself. See https://cloud.google.com/apis/design/glossary for + * detailed terminology. + * + * @generated from message google.protobuf.Api + */ +export type ApiJson = { + /** + * The fully qualified name of this interface, including package name + * followed by the interface's simple name. + * + * @generated from field: string name = 1; + */ + name?: string; + /** + * The methods of this interface, in unspecified order. + * + * @generated from field: repeated google.protobuf.Method methods = 2; + */ + methods?: MethodJson[]; + /** + * Any metadata attached to the interface. + * + * @generated from field: repeated google.protobuf.Option options = 3; + */ + options?: OptionJson[]; + /** + * A version string for this interface. If specified, must have the form + * `major-version.minor-version`, as in `1.10`. If the minor version is + * omitted, it defaults to zero. If the entire version field is empty, the + * major version is derived from the package name, as outlined below. If the + * field is not empty, the version in the package name will be verified to be + * consistent with what is provided here. + * + * The versioning schema uses [semantic + * versioning](http://semver.org) where the major version number + * indicates a breaking change and the minor version an additive, + * non-breaking change. Both version numbers are signals to users + * what to expect from different versions, and should be carefully + * chosen based on the product plan. + * + * The major version is also reflected in the package name of the + * interface, which must end in `v`, as in + * `google.feature.v1`. For major versions 0 and 1, the suffix can + * be omitted. Zero major versions must only be used for + * experimental, non-GA interfaces. + * + * + * @generated from field: string version = 4; + */ + version?: string; + /** + * Source context for the protocol buffer service represented by this + * message. + * + * @generated from field: google.protobuf.SourceContext source_context = 5; + */ + sourceContext?: SourceContextJson; + /** + * Included interfaces. See [Mixin][]. + * + * @generated from field: repeated google.protobuf.Mixin mixins = 6; + */ + mixins?: MixinJson[]; + /** + * The source syntax of the service. + * + * @generated from field: google.protobuf.Syntax syntax = 7; + */ + syntax?: SyntaxJson; +}; +/** + * Describes the message google.protobuf.Api. + * Use `create(ApiSchema)` to create a new message. + */ +export declare const ApiSchema: GenMessage; +/** + * Method represents a method of an API interface. + * + * @generated from message google.protobuf.Method + */ +export type Method = Message<"google.protobuf.Method"> & { + /** + * The simple name of this method. + * + * @generated from field: string name = 1; + */ + name: string; + /** + * A URL of the input message type. + * + * @generated from field: string request_type_url = 2; + */ + requestTypeUrl: string; + /** + * If true, the request is streamed. + * + * @generated from field: bool request_streaming = 3; + */ + requestStreaming: boolean; + /** + * The URL of the output message type. + * + * @generated from field: string response_type_url = 4; + */ + responseTypeUrl: string; + /** + * If true, the response is streamed. + * + * @generated from field: bool response_streaming = 5; + */ + responseStreaming: boolean; + /** + * Any metadata attached to the method. + * + * @generated from field: repeated google.protobuf.Option options = 6; + */ + options: Option[]; + /** + * The source syntax of this method. + * + * @generated from field: google.protobuf.Syntax syntax = 7; + */ + syntax: Syntax; +}; +/** + * Method represents a method of an API interface. + * + * @generated from message google.protobuf.Method + */ +export type MethodJson = { + /** + * The simple name of this method. + * + * @generated from field: string name = 1; + */ + name?: string; + /** + * A URL of the input message type. + * + * @generated from field: string request_type_url = 2; + */ + requestTypeUrl?: string; + /** + * If true, the request is streamed. + * + * @generated from field: bool request_streaming = 3; + */ + requestStreaming?: boolean; + /** + * The URL of the output message type. + * + * @generated from field: string response_type_url = 4; + */ + responseTypeUrl?: string; + /** + * If true, the response is streamed. + * + * @generated from field: bool response_streaming = 5; + */ + responseStreaming?: boolean; + /** + * Any metadata attached to the method. + * + * @generated from field: repeated google.protobuf.Option options = 6; + */ + options?: OptionJson[]; + /** + * The source syntax of this method. + * + * @generated from field: google.protobuf.Syntax syntax = 7; + */ + syntax?: SyntaxJson; +}; +/** + * Describes the message google.protobuf.Method. + * Use `create(MethodSchema)` to create a new message. + */ +export declare const MethodSchema: GenMessage; +/** + * Declares an API Interface to be included in this interface. The including + * interface must redeclare all the methods from the included interface, but + * documentation and options are inherited as follows: + * + * - If after comment and whitespace stripping, the documentation + * string of the redeclared method is empty, it will be inherited + * from the original method. + * + * - Each annotation belonging to the service config (http, + * visibility) which is not set in the redeclared method will be + * inherited. + * + * - If an http annotation is inherited, the path pattern will be + * modified as follows. Any version prefix will be replaced by the + * version of the including interface plus the [root][] path if + * specified. + * + * Example of a simple mixin: + * + * package google.acl.v1; + * service AccessControl { + * // Get the underlying ACL object. + * rpc GetAcl(GetAclRequest) returns (Acl) { + * option (google.api.http).get = "/v1/{resource=**}:getAcl"; + * } + * } + * + * package google.storage.v2; + * service Storage { + * rpc GetAcl(GetAclRequest) returns (Acl); + * + * // Get a data record. + * rpc GetData(GetDataRequest) returns (Data) { + * option (google.api.http).get = "/v2/{resource=**}"; + * } + * } + * + * Example of a mixin configuration: + * + * apis: + * - name: google.storage.v2.Storage + * mixins: + * - name: google.acl.v1.AccessControl + * + * The mixin construct implies that all methods in `AccessControl` are + * also declared with same name and request/response types in + * `Storage`. A documentation generator or annotation processor will + * see the effective `Storage.GetAcl` method after inheriting + * documentation and annotations as follows: + * + * service Storage { + * // Get the underlying ACL object. + * rpc GetAcl(GetAclRequest) returns (Acl) { + * option (google.api.http).get = "/v2/{resource=**}:getAcl"; + * } + * ... + * } + * + * Note how the version in the path pattern changed from `v1` to `v2`. + * + * If the `root` field in the mixin is specified, it should be a + * relative path under which inherited HTTP paths are placed. Example: + * + * apis: + * - name: google.storage.v2.Storage + * mixins: + * - name: google.acl.v1.AccessControl + * root: acls + * + * This implies the following inherited HTTP annotation: + * + * service Storage { + * // Get the underlying ACL object. + * rpc GetAcl(GetAclRequest) returns (Acl) { + * option (google.api.http).get = "/v2/acls/{resource=**}:getAcl"; + * } + * ... + * } + * + * @generated from message google.protobuf.Mixin + */ +export type Mixin = Message<"google.protobuf.Mixin"> & { + /** + * The fully qualified name of the interface which is included. + * + * @generated from field: string name = 1; + */ + name: string; + /** + * If non-empty specifies a path under which inherited HTTP paths + * are rooted. + * + * @generated from field: string root = 2; + */ + root: string; +}; +/** + * Declares an API Interface to be included in this interface. The including + * interface must redeclare all the methods from the included interface, but + * documentation and options are inherited as follows: + * + * - If after comment and whitespace stripping, the documentation + * string of the redeclared method is empty, it will be inherited + * from the original method. + * + * - Each annotation belonging to the service config (http, + * visibility) which is not set in the redeclared method will be + * inherited. + * + * - If an http annotation is inherited, the path pattern will be + * modified as follows. Any version prefix will be replaced by the + * version of the including interface plus the [root][] path if + * specified. + * + * Example of a simple mixin: + * + * package google.acl.v1; + * service AccessControl { + * // Get the underlying ACL object. + * rpc GetAcl(GetAclRequest) returns (Acl) { + * option (google.api.http).get = "/v1/{resource=**}:getAcl"; + * } + * } + * + * package google.storage.v2; + * service Storage { + * rpc GetAcl(GetAclRequest) returns (Acl); + * + * // Get a data record. + * rpc GetData(GetDataRequest) returns (Data) { + * option (google.api.http).get = "/v2/{resource=**}"; + * } + * } + * + * Example of a mixin configuration: + * + * apis: + * - name: google.storage.v2.Storage + * mixins: + * - name: google.acl.v1.AccessControl + * + * The mixin construct implies that all methods in `AccessControl` are + * also declared with same name and request/response types in + * `Storage`. A documentation generator or annotation processor will + * see the effective `Storage.GetAcl` method after inheriting + * documentation and annotations as follows: + * + * service Storage { + * // Get the underlying ACL object. + * rpc GetAcl(GetAclRequest) returns (Acl) { + * option (google.api.http).get = "/v2/{resource=**}:getAcl"; + * } + * ... + * } + * + * Note how the version in the path pattern changed from `v1` to `v2`. + * + * If the `root` field in the mixin is specified, it should be a + * relative path under which inherited HTTP paths are placed. Example: + * + * apis: + * - name: google.storage.v2.Storage + * mixins: + * - name: google.acl.v1.AccessControl + * root: acls + * + * This implies the following inherited HTTP annotation: + * + * service Storage { + * // Get the underlying ACL object. + * rpc GetAcl(GetAclRequest) returns (Acl) { + * option (google.api.http).get = "/v2/acls/{resource=**}:getAcl"; + * } + * ... + * } + * + * @generated from message google.protobuf.Mixin + */ +export type MixinJson = { + /** + * The fully qualified name of the interface which is included. + * + * @generated from field: string name = 1; + */ + name?: string; + /** + * If non-empty specifies a path under which inherited HTTP paths + * are rooted. + * + * @generated from field: string root = 2; + */ + root?: string; +}; +/** + * Describes the message google.protobuf.Mixin. + * Use `create(MixinSchema)` to create a new message. + */ +export declare const MixinSchema: GenMessage; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/api_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/api_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..af38db52c1315c363629c80d88e98f67b037a9be --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/api_pb.js @@ -0,0 +1,36 @@ +// Copyright 2021-2025 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. +import { fileDesc } from "../../../../codegenv2/file.js"; +import { file_google_protobuf_source_context } from "./source_context_pb.js"; +import { file_google_protobuf_type } from "./type_pb.js"; +import { messageDesc } from "../../../../codegenv2/message.js"; +/** + * Describes the file google/protobuf/api.proto. + */ +export const file_google_protobuf_api = /*@__PURE__*/ fileDesc("Chlnb29nbGUvcHJvdG9idWYvYXBpLnByb3RvEg9nb29nbGUucHJvdG9idWYigQIKA0FwaRIMCgRuYW1lGAEgASgJEigKB21ldGhvZHMYAiADKAsyFy5nb29nbGUucHJvdG9idWYuTWV0aG9kEigKB29wdGlvbnMYAyADKAsyFy5nb29nbGUucHJvdG9idWYuT3B0aW9uEg8KB3ZlcnNpb24YBCABKAkSNgoOc291cmNlX2NvbnRleHQYBSABKAsyHi5nb29nbGUucHJvdG9idWYuU291cmNlQ29udGV4dBImCgZtaXhpbnMYBiADKAsyFi5nb29nbGUucHJvdG9idWYuTWl4aW4SJwoGc3ludGF4GAcgASgOMhcuZ29vZ2xlLnByb3RvYnVmLlN5bnRheCLVAQoGTWV0aG9kEgwKBG5hbWUYASABKAkSGAoQcmVxdWVzdF90eXBlX3VybBgCIAEoCRIZChFyZXF1ZXN0X3N0cmVhbWluZxgDIAEoCBIZChFyZXNwb25zZV90eXBlX3VybBgEIAEoCRIaChJyZXNwb25zZV9zdHJlYW1pbmcYBSABKAgSKAoHb3B0aW9ucxgGIAMoCzIXLmdvb2dsZS5wcm90b2J1Zi5PcHRpb24SJwoGc3ludGF4GAcgASgOMhcuZ29vZ2xlLnByb3RvYnVmLlN5bnRheCIjCgVNaXhpbhIMCgRuYW1lGAEgASgJEgwKBHJvb3QYAiABKAlCdgoTY29tLmdvb2dsZS5wcm90b2J1ZkIIQXBpUHJvdG9QAVosZ29vZ2xlLmdvbGFuZy5vcmcvcHJvdG9idWYvdHlwZXMva25vd24vYXBpcGKiAgNHUEKqAh5Hb29nbGUuUHJvdG9idWYuV2VsbEtub3duVHlwZXNiBnByb3RvMw", [file_google_protobuf_source_context, file_google_protobuf_type]); +/** + * Describes the message google.protobuf.Api. + * Use `create(ApiSchema)` to create a new message. + */ +export const ApiSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_api, 0); +/** + * Describes the message google.protobuf.Method. + * Use `create(MethodSchema)` to create a new message. + */ +export const MethodSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_api, 1); +/** + * Describes the message google.protobuf.Mixin. + * Use `create(MixinSchema)` to create a new message. + */ +export const MixinSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_api, 2); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/compiler/plugin_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/compiler/plugin_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2c3eaf6d8c630105a7fb17d2cd2a944234fcbe14 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/compiler/plugin_pb.d.ts @@ -0,0 +1,490 @@ +import type { GenEnum, GenFile, GenMessage } from "../../../../../codegenv2/types.js"; +import type { FileDescriptorProto, FileDescriptorProtoJson, GeneratedCodeInfo, GeneratedCodeInfoJson } from "../descriptor_pb.js"; +import type { Message } from "../../../../../types.js"; +/** + * Describes the file google/protobuf/compiler/plugin.proto. + */ +export declare const file_google_protobuf_compiler_plugin: GenFile; +/** + * The version number of protocol compiler. + * + * @generated from message google.protobuf.compiler.Version + */ +export type Version = Message<"google.protobuf.compiler.Version"> & { + /** + * @generated from field: optional int32 major = 1; + */ + major: number; + /** + * @generated from field: optional int32 minor = 2; + */ + minor: number; + /** + * @generated from field: optional int32 patch = 3; + */ + patch: number; + /** + * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should + * be empty for mainline stable releases. + * + * @generated from field: optional string suffix = 4; + */ + suffix: string; +}; +/** + * The version number of protocol compiler. + * + * @generated from message google.protobuf.compiler.Version + */ +export type VersionJson = { + /** + * @generated from field: optional int32 major = 1; + */ + major?: number; + /** + * @generated from field: optional int32 minor = 2; + */ + minor?: number; + /** + * @generated from field: optional int32 patch = 3; + */ + patch?: number; + /** + * A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should + * be empty for mainline stable releases. + * + * @generated from field: optional string suffix = 4; + */ + suffix?: string; +}; +/** + * Describes the message google.protobuf.compiler.Version. + * Use `create(VersionSchema)` to create a new message. + */ +export declare const VersionSchema: GenMessage; +/** + * An encoded CodeGeneratorRequest is written to the plugin's stdin. + * + * @generated from message google.protobuf.compiler.CodeGeneratorRequest + */ +export type CodeGeneratorRequest = Message<"google.protobuf.compiler.CodeGeneratorRequest"> & { + /** + * The .proto files that were explicitly listed on the command-line. The + * code generator should generate code only for these files. Each file's + * descriptor will be included in proto_file, below. + * + * @generated from field: repeated string file_to_generate = 1; + */ + fileToGenerate: string[]; + /** + * The generator parameter passed on the command-line. + * + * @generated from field: optional string parameter = 2; + */ + parameter: string; + /** + * FileDescriptorProtos for all files in files_to_generate and everything + * they import. The files will appear in topological order, so each file + * appears before any file that imports it. + * + * Note: the files listed in files_to_generate will include runtime-retention + * options only, but all other files will include source-retention options. + * The source_file_descriptors field below is available in case you need + * source-retention options for files_to_generate. + * + * protoc guarantees that all proto_files will be written after + * the fields above, even though this is not technically guaranteed by the + * protobuf wire format. This theoretically could allow a plugin to stream + * in the FileDescriptorProtos and handle them one by one rather than read + * the entire set into memory at once. However, as of this writing, this + * is not similarly optimized on protoc's end -- it will store all fields in + * memory at once before sending them to the plugin. + * + * Type names of fields and extensions in the FileDescriptorProto are always + * fully qualified. + * + * @generated from field: repeated google.protobuf.FileDescriptorProto proto_file = 15; + */ + protoFile: FileDescriptorProto[]; + /** + * File descriptors with all options, including source-retention options. + * These descriptors are only provided for the files listed in + * files_to_generate. + * + * @generated from field: repeated google.protobuf.FileDescriptorProto source_file_descriptors = 17; + */ + sourceFileDescriptors: FileDescriptorProto[]; + /** + * The version number of protocol compiler. + * + * @generated from field: optional google.protobuf.compiler.Version compiler_version = 3; + */ + compilerVersion?: Version; +}; +/** + * An encoded CodeGeneratorRequest is written to the plugin's stdin. + * + * @generated from message google.protobuf.compiler.CodeGeneratorRequest + */ +export type CodeGeneratorRequestJson = { + /** + * The .proto files that were explicitly listed on the command-line. The + * code generator should generate code only for these files. Each file's + * descriptor will be included in proto_file, below. + * + * @generated from field: repeated string file_to_generate = 1; + */ + fileToGenerate?: string[]; + /** + * The generator parameter passed on the command-line. + * + * @generated from field: optional string parameter = 2; + */ + parameter?: string; + /** + * FileDescriptorProtos for all files in files_to_generate and everything + * they import. The files will appear in topological order, so each file + * appears before any file that imports it. + * + * Note: the files listed in files_to_generate will include runtime-retention + * options only, but all other files will include source-retention options. + * The source_file_descriptors field below is available in case you need + * source-retention options for files_to_generate. + * + * protoc guarantees that all proto_files will be written after + * the fields above, even though this is not technically guaranteed by the + * protobuf wire format. This theoretically could allow a plugin to stream + * in the FileDescriptorProtos and handle them one by one rather than read + * the entire set into memory at once. However, as of this writing, this + * is not similarly optimized on protoc's end -- it will store all fields in + * memory at once before sending them to the plugin. + * + * Type names of fields and extensions in the FileDescriptorProto are always + * fully qualified. + * + * @generated from field: repeated google.protobuf.FileDescriptorProto proto_file = 15; + */ + protoFile?: FileDescriptorProtoJson[]; + /** + * File descriptors with all options, including source-retention options. + * These descriptors are only provided for the files listed in + * files_to_generate. + * + * @generated from field: repeated google.protobuf.FileDescriptorProto source_file_descriptors = 17; + */ + sourceFileDescriptors?: FileDescriptorProtoJson[]; + /** + * The version number of protocol compiler. + * + * @generated from field: optional google.protobuf.compiler.Version compiler_version = 3; + */ + compilerVersion?: VersionJson; +}; +/** + * Describes the message google.protobuf.compiler.CodeGeneratorRequest. + * Use `create(CodeGeneratorRequestSchema)` to create a new message. + */ +export declare const CodeGeneratorRequestSchema: GenMessage; +/** + * The plugin writes an encoded CodeGeneratorResponse to stdout. + * + * @generated from message google.protobuf.compiler.CodeGeneratorResponse + */ +export type CodeGeneratorResponse = Message<"google.protobuf.compiler.CodeGeneratorResponse"> & { + /** + * Error message. If non-empty, code generation failed. The plugin process + * should exit with status code zero even if it reports an error in this way. + * + * This should be used to indicate errors in .proto files which prevent the + * code generator from generating correct code. Errors which indicate a + * problem in protoc itself -- such as the input CodeGeneratorRequest being + * unparseable -- should be reported by writing a message to stderr and + * exiting with a non-zero status code. + * + * @generated from field: optional string error = 1; + */ + error: string; + /** + * A bitmask of supported features that the code generator supports. + * This is a bitwise "or" of values from the Feature enum. + * + * @generated from field: optional uint64 supported_features = 2; + */ + supportedFeatures: bigint; + /** + * The minimum edition this plugin supports. This will be treated as an + * Edition enum, but we want to allow unknown values. It should be specified + * according the edition enum value, *not* the edition number. Only takes + * effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + * + * @generated from field: optional int32 minimum_edition = 3; + */ + minimumEdition: number; + /** + * The maximum edition this plugin supports. This will be treated as an + * Edition enum, but we want to allow unknown values. It should be specified + * according the edition enum value, *not* the edition number. Only takes + * effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + * + * @generated from field: optional int32 maximum_edition = 4; + */ + maximumEdition: number; + /** + * @generated from field: repeated google.protobuf.compiler.CodeGeneratorResponse.File file = 15; + */ + file: CodeGeneratorResponse_File[]; +}; +/** + * The plugin writes an encoded CodeGeneratorResponse to stdout. + * + * @generated from message google.protobuf.compiler.CodeGeneratorResponse + */ +export type CodeGeneratorResponseJson = { + /** + * Error message. If non-empty, code generation failed. The plugin process + * should exit with status code zero even if it reports an error in this way. + * + * This should be used to indicate errors in .proto files which prevent the + * code generator from generating correct code. Errors which indicate a + * problem in protoc itself -- such as the input CodeGeneratorRequest being + * unparseable -- should be reported by writing a message to stderr and + * exiting with a non-zero status code. + * + * @generated from field: optional string error = 1; + */ + error?: string; + /** + * A bitmask of supported features that the code generator supports. + * This is a bitwise "or" of values from the Feature enum. + * + * @generated from field: optional uint64 supported_features = 2; + */ + supportedFeatures?: string; + /** + * The minimum edition this plugin supports. This will be treated as an + * Edition enum, but we want to allow unknown values. It should be specified + * according the edition enum value, *not* the edition number. Only takes + * effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + * + * @generated from field: optional int32 minimum_edition = 3; + */ + minimumEdition?: number; + /** + * The maximum edition this plugin supports. This will be treated as an + * Edition enum, but we want to allow unknown values. It should be specified + * according the edition enum value, *not* the edition number. Only takes + * effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + * + * @generated from field: optional int32 maximum_edition = 4; + */ + maximumEdition?: number; + /** + * @generated from field: repeated google.protobuf.compiler.CodeGeneratorResponse.File file = 15; + */ + file?: CodeGeneratorResponse_FileJson[]; +}; +/** + * Describes the message google.protobuf.compiler.CodeGeneratorResponse. + * Use `create(CodeGeneratorResponseSchema)` to create a new message. + */ +export declare const CodeGeneratorResponseSchema: GenMessage; +/** + * Represents a single generated file. + * + * @generated from message google.protobuf.compiler.CodeGeneratorResponse.File + */ +export type CodeGeneratorResponse_File = Message<"google.protobuf.compiler.CodeGeneratorResponse.File"> & { + /** + * The file name, relative to the output directory. The name must not + * contain "." or ".." components and must be relative, not be absolute (so, + * the file cannot lie outside the output directory). "/" must be used as + * the path separator, not "\". + * + * If the name is omitted, the content will be appended to the previous + * file. This allows the generator to break large files into small chunks, + * and allows the generated text to be streamed back to protoc so that large + * files need not reside completely in memory at one time. Note that as of + * this writing protoc does not optimize for this -- it will read the entire + * CodeGeneratorResponse before writing files to disk. + * + * @generated from field: optional string name = 1; + */ + name: string; + /** + * If non-empty, indicates that the named file should already exist, and the + * content here is to be inserted into that file at a defined insertion + * point. This feature allows a code generator to extend the output + * produced by another code generator. The original generator may provide + * insertion points by placing special annotations in the file that look + * like: + * @@protoc_insertion_point(NAME) + * The annotation can have arbitrary text before and after it on the line, + * which allows it to be placed in a comment. NAME should be replaced with + * an identifier naming the point -- this is what other generators will use + * as the insertion_point. Code inserted at this point will be placed + * immediately above the line containing the insertion point (thus multiple + * insertions to the same point will come out in the order they were added). + * The double-@ is intended to make it unlikely that the generated code + * could contain things that look like insertion points by accident. + * + * For example, the C++ code generator places the following line in the + * .pb.h files that it generates: + * // @@protoc_insertion_point(namespace_scope) + * This line appears within the scope of the file's package namespace, but + * outside of any particular class. Another plugin can then specify the + * insertion_point "namespace_scope" to generate additional classes or + * other declarations that should be placed in this scope. + * + * Note that if the line containing the insertion point begins with + * whitespace, the same whitespace will be added to every line of the + * inserted text. This is useful for languages like Python, where + * indentation matters. In these languages, the insertion point comment + * should be indented the same amount as any inserted code will need to be + * in order to work correctly in that context. + * + * The code generator that generates the initial file and the one which + * inserts into it must both run as part of a single invocation of protoc. + * Code generators are executed in the order in which they appear on the + * command line. + * + * If |insertion_point| is present, |name| must also be present. + * + * @generated from field: optional string insertion_point = 2; + */ + insertionPoint: string; + /** + * The file contents. + * + * @generated from field: optional string content = 15; + */ + content: string; + /** + * Information describing the file content being inserted. If an insertion + * point is used, this information will be appropriately offset and inserted + * into the code generation metadata for the generated files. + * + * @generated from field: optional google.protobuf.GeneratedCodeInfo generated_code_info = 16; + */ + generatedCodeInfo?: GeneratedCodeInfo; +}; +/** + * Represents a single generated file. + * + * @generated from message google.protobuf.compiler.CodeGeneratorResponse.File + */ +export type CodeGeneratorResponse_FileJson = { + /** + * The file name, relative to the output directory. The name must not + * contain "." or ".." components and must be relative, not be absolute (so, + * the file cannot lie outside the output directory). "/" must be used as + * the path separator, not "\". + * + * If the name is omitted, the content will be appended to the previous + * file. This allows the generator to break large files into small chunks, + * and allows the generated text to be streamed back to protoc so that large + * files need not reside completely in memory at one time. Note that as of + * this writing protoc does not optimize for this -- it will read the entire + * CodeGeneratorResponse before writing files to disk. + * + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * If non-empty, indicates that the named file should already exist, and the + * content here is to be inserted into that file at a defined insertion + * point. This feature allows a code generator to extend the output + * produced by another code generator. The original generator may provide + * insertion points by placing special annotations in the file that look + * like: + * @@protoc_insertion_point(NAME) + * The annotation can have arbitrary text before and after it on the line, + * which allows it to be placed in a comment. NAME should be replaced with + * an identifier naming the point -- this is what other generators will use + * as the insertion_point. Code inserted at this point will be placed + * immediately above the line containing the insertion point (thus multiple + * insertions to the same point will come out in the order they were added). + * The double-@ is intended to make it unlikely that the generated code + * could contain things that look like insertion points by accident. + * + * For example, the C++ code generator places the following line in the + * .pb.h files that it generates: + * // @@protoc_insertion_point(namespace_scope) + * This line appears within the scope of the file's package namespace, but + * outside of any particular class. Another plugin can then specify the + * insertion_point "namespace_scope" to generate additional classes or + * other declarations that should be placed in this scope. + * + * Note that if the line containing the insertion point begins with + * whitespace, the same whitespace will be added to every line of the + * inserted text. This is useful for languages like Python, where + * indentation matters. In these languages, the insertion point comment + * should be indented the same amount as any inserted code will need to be + * in order to work correctly in that context. + * + * The code generator that generates the initial file and the one which + * inserts into it must both run as part of a single invocation of protoc. + * Code generators are executed in the order in which they appear on the + * command line. + * + * If |insertion_point| is present, |name| must also be present. + * + * @generated from field: optional string insertion_point = 2; + */ + insertionPoint?: string; + /** + * The file contents. + * + * @generated from field: optional string content = 15; + */ + content?: string; + /** + * Information describing the file content being inserted. If an insertion + * point is used, this information will be appropriately offset and inserted + * into the code generation metadata for the generated files. + * + * @generated from field: optional google.protobuf.GeneratedCodeInfo generated_code_info = 16; + */ + generatedCodeInfo?: GeneratedCodeInfoJson; +}; +/** + * Describes the message google.protobuf.compiler.CodeGeneratorResponse.File. + * Use `create(CodeGeneratorResponse_FileSchema)` to create a new message. + */ +export declare const CodeGeneratorResponse_FileSchema: GenMessage; +/** + * Sync with code_generator.h. + * + * @generated from enum google.protobuf.compiler.CodeGeneratorResponse.Feature + */ +export declare enum CodeGeneratorResponse_Feature { + /** + * @generated from enum value: FEATURE_NONE = 0; + */ + NONE = 0, + /** + * @generated from enum value: FEATURE_PROTO3_OPTIONAL = 1; + */ + PROTO3_OPTIONAL = 1, + /** + * @generated from enum value: FEATURE_SUPPORTS_EDITIONS = 2; + */ + SUPPORTS_EDITIONS = 2 +} +/** + * Sync with code_generator.h. + * + * @generated from enum google.protobuf.compiler.CodeGeneratorResponse.Feature + */ +export type CodeGeneratorResponse_FeatureJson = "FEATURE_NONE" | "FEATURE_PROTO3_OPTIONAL" | "FEATURE_SUPPORTS_EDITIONS"; +/** + * Describes the enum google.protobuf.compiler.CodeGeneratorResponse.Feature. + */ +export declare const CodeGeneratorResponse_FeatureSchema: GenEnum; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/compiler/plugin_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/compiler/plugin_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..2ff5d7960eddb2baf53d40f8a08f053d3fc24ecf --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/compiler/plugin_pb.js @@ -0,0 +1,65 @@ +// Copyright 2021-2025 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. +import { fileDesc } from "../../../../../codegenv2/file.js"; +import { file_google_protobuf_descriptor } from "../descriptor_pb.js"; +import { messageDesc } from "../../../../../codegenv2/message.js"; +import { enumDesc } from "../../../../../codegenv2/enum.js"; +/** + * Describes the file google/protobuf/compiler/plugin.proto. + */ +export const file_google_protobuf_compiler_plugin = /*@__PURE__*/ fileDesc("CiVnb29nbGUvcHJvdG9idWYvY29tcGlsZXIvcGx1Z2luLnByb3RvEhhnb29nbGUucHJvdG9idWYuY29tcGlsZXIiRgoHVmVyc2lvbhINCgVtYWpvchgBIAEoBRINCgVtaW5vchgCIAEoBRINCgVwYXRjaBgDIAEoBRIOCgZzdWZmaXgYBCABKAkigQIKFENvZGVHZW5lcmF0b3JSZXF1ZXN0EhgKEGZpbGVfdG9fZ2VuZXJhdGUYASADKAkSEQoJcGFyYW1ldGVyGAIgASgJEjgKCnByb3RvX2ZpbGUYDyADKAsyJC5nb29nbGUucHJvdG9idWYuRmlsZURlc2NyaXB0b3JQcm90bxJFChdzb3VyY2VfZmlsZV9kZXNjcmlwdG9ycxgRIAMoCzIkLmdvb2dsZS5wcm90b2J1Zi5GaWxlRGVzY3JpcHRvclByb3RvEjsKEGNvbXBpbGVyX3ZlcnNpb24YAyABKAsyIS5nb29nbGUucHJvdG9idWYuY29tcGlsZXIuVmVyc2lvbiKSAwoVQ29kZUdlbmVyYXRvclJlc3BvbnNlEg0KBWVycm9yGAEgASgJEhoKEnN1cHBvcnRlZF9mZWF0dXJlcxgCIAEoBBIXCg9taW5pbXVtX2VkaXRpb24YAyABKAUSFwoPbWF4aW11bV9lZGl0aW9uGAQgASgFEkIKBGZpbGUYDyADKAsyNC5nb29nbGUucHJvdG9idWYuY29tcGlsZXIuQ29kZUdlbmVyYXRvclJlc3BvbnNlLkZpbGUafwoERmlsZRIMCgRuYW1lGAEgASgJEhcKD2luc2VydGlvbl9wb2ludBgCIAEoCRIPCgdjb250ZW50GA8gASgJEj8KE2dlbmVyYXRlZF9jb2RlX2luZm8YECABKAsyIi5nb29nbGUucHJvdG9idWYuR2VuZXJhdGVkQ29kZUluZm8iVwoHRmVhdHVyZRIQCgxGRUFUVVJFX05PTkUQABIbChdGRUFUVVJFX1BST1RPM19PUFRJT05BTBABEh0KGUZFQVRVUkVfU1VQUE9SVFNfRURJVElPTlMQAkJyChxjb20uZ29vZ2xlLnByb3RvYnVmLmNvbXBpbGVyQgxQbHVnaW5Qcm90b3NaKWdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL3BsdWdpbnBiqgIYR29vZ2xlLlByb3RvYnVmLkNvbXBpbGVy", [file_google_protobuf_descriptor]); +/** + * Describes the message google.protobuf.compiler.Version. + * Use `create(VersionSchema)` to create a new message. + */ +export const VersionSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_compiler_plugin, 0); +/** + * Describes the message google.protobuf.compiler.CodeGeneratorRequest. + * Use `create(CodeGeneratorRequestSchema)` to create a new message. + */ +export const CodeGeneratorRequestSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_compiler_plugin, 1); +/** + * Describes the message google.protobuf.compiler.CodeGeneratorResponse. + * Use `create(CodeGeneratorResponseSchema)` to create a new message. + */ +export const CodeGeneratorResponseSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_compiler_plugin, 2); +/** + * Describes the message google.protobuf.compiler.CodeGeneratorResponse.File. + * Use `create(CodeGeneratorResponse_FileSchema)` to create a new message. + */ +export const CodeGeneratorResponse_FileSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_compiler_plugin, 2, 0); +/** + * Sync with code_generator.h. + * + * @generated from enum google.protobuf.compiler.CodeGeneratorResponse.Feature + */ +export var CodeGeneratorResponse_Feature; +(function (CodeGeneratorResponse_Feature) { + /** + * @generated from enum value: FEATURE_NONE = 0; + */ + CodeGeneratorResponse_Feature[CodeGeneratorResponse_Feature["NONE"] = 0] = "NONE"; + /** + * @generated from enum value: FEATURE_PROTO3_OPTIONAL = 1; + */ + CodeGeneratorResponse_Feature[CodeGeneratorResponse_Feature["PROTO3_OPTIONAL"] = 1] = "PROTO3_OPTIONAL"; + /** + * @generated from enum value: FEATURE_SUPPORTS_EDITIONS = 2; + */ + CodeGeneratorResponse_Feature[CodeGeneratorResponse_Feature["SUPPORTS_EDITIONS"] = 2] = "SUPPORTS_EDITIONS"; +})(CodeGeneratorResponse_Feature || (CodeGeneratorResponse_Feature = {})); +/** + * Describes the enum google.protobuf.compiler.CodeGeneratorResponse.Feature. + */ +export const CodeGeneratorResponse_FeatureSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_compiler_plugin, 2, 0); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/cpp_features_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/cpp_features_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7da3c6db13d89af5b54049f3c79eb59cfb442d35 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/cpp_features_pb.d.ts @@ -0,0 +1,91 @@ +import type { GenEnum, GenExtension, GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { FeatureSet } from "./descriptor_pb.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/cpp_features.proto. + */ +export declare const file_google_protobuf_cpp_features: GenFile; +/** + * @generated from message pb.CppFeatures + */ +export type CppFeatures = Message<"pb.CppFeatures"> & { + /** + * Whether or not to treat an enum field as closed. This option is only + * applicable to enum fields, and will be removed in the future. It is + * consistent with the legacy behavior of using proto3 enum types for proto2 + * fields. + * + * @generated from field: optional bool legacy_closed_enum = 1; + */ + legacyClosedEnum: boolean; + /** + * @generated from field: optional pb.CppFeatures.StringType string_type = 2; + */ + stringType: CppFeatures_StringType; + /** + * @generated from field: optional bool enum_name_uses_string_view = 3; + */ + enumNameUsesStringView: boolean; +}; +/** + * @generated from message pb.CppFeatures + */ +export type CppFeaturesJson = { + /** + * Whether or not to treat an enum field as closed. This option is only + * applicable to enum fields, and will be removed in the future. It is + * consistent with the legacy behavior of using proto3 enum types for proto2 + * fields. + * + * @generated from field: optional bool legacy_closed_enum = 1; + */ + legacyClosedEnum?: boolean; + /** + * @generated from field: optional pb.CppFeatures.StringType string_type = 2; + */ + stringType?: CppFeatures_StringTypeJson; + /** + * @generated from field: optional bool enum_name_uses_string_view = 3; + */ + enumNameUsesStringView?: boolean; +}; +/** + * Describes the message pb.CppFeatures. + * Use `create(CppFeaturesSchema)` to create a new message. + */ +export declare const CppFeaturesSchema: GenMessage; +/** + * @generated from enum pb.CppFeatures.StringType + */ +export declare enum CppFeatures_StringType { + /** + * @generated from enum value: STRING_TYPE_UNKNOWN = 0; + */ + STRING_TYPE_UNKNOWN = 0, + /** + * @generated from enum value: VIEW = 1; + */ + VIEW = 1, + /** + * @generated from enum value: CORD = 2; + */ + CORD = 2, + /** + * @generated from enum value: STRING = 3; + */ + STRING = 3 +} +/** + * @generated from enum pb.CppFeatures.StringType + */ +export type CppFeatures_StringTypeJson = "STRING_TYPE_UNKNOWN" | "VIEW" | "CORD" | "STRING"; +/** + * Describes the enum pb.CppFeatures.StringType. + */ +export declare const CppFeatures_StringTypeSchema: GenEnum; +/** + * @generated from extension: optional pb.CppFeatures cpp = 1000; + */ +export declare const cpp: GenExtension; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/cpp_features_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/cpp_features_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..213eed386bab06524cbacf4754687241af3dd6f9 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/cpp_features_pb.js @@ -0,0 +1,57 @@ +// Copyright 2021-2025 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. +import { fileDesc } from "../../../../codegenv2/file.js"; +import { file_google_protobuf_descriptor } from "./descriptor_pb.js"; +import { messageDesc } from "../../../../codegenv2/message.js"; +import { enumDesc } from "../../../../codegenv2/enum.js"; +import { extDesc } from "../../../../codegenv2/extension.js"; +/** + * Describes the file google/protobuf/cpp_features.proto. + */ +export const file_google_protobuf_cpp_features = /*@__PURE__*/ fileDesc("CiJnb29nbGUvcHJvdG9idWYvY3BwX2ZlYXR1cmVzLnByb3RvEgJwYiL8AwoLQ3BwRmVhdHVyZXMS+wEKEmxlZ2FjeV9jbG9zZWRfZW51bRgBIAEoCELeAYgBAZgBBJgBAaIBCRIEdHJ1ZRiEB6IBChIFZmFsc2UY5weyAbgBCOgHEOgHGq8BVGhlIGxlZ2FjeSBjbG9zZWQgZW51bSBiZWhhdmlvciBpbiBDKysgaXMgZGVwcmVjYXRlZCBhbmQgaXMgc2NoZWR1bGVkIHRvIGJlIHJlbW92ZWQgaW4gZWRpdGlvbiAyMDI1LiAgU2VlIGh0dHA6Ly9wcm90b2J1Zi5kZXYvcHJvZ3JhbW1pbmctZ3VpZGVzL2VudW0vI2NwcCBmb3IgbW9yZSBpbmZvcm1hdGlvbhJaCgtzdHJpbmdfdHlwZRgCIAEoDjIaLnBiLkNwcEZlYXR1cmVzLlN0cmluZ1R5cGVCKYgBAZgBBJgBAaIBCxIGU1RSSU5HGIQHogEJEgRWSUVXGOkHsgEDCOgHEkwKGmVudW1fbmFtZV91c2VzX3N0cmluZ192aWV3GAMgASgIQiiIAQKYAQaYAQGiAQoSBWZhbHNlGIQHogEJEgR0cnVlGOkHsgEDCOkHIkUKClN0cmluZ1R5cGUSFwoTU1RSSU5HX1RZUEVfVU5LTk9XThAAEggKBFZJRVcQARIICgRDT1JEEAISCgoGU1RSSU5HEAM6PwoDY3BwEhsuZ29vZ2xlLnByb3RvYnVmLkZlYXR1cmVTZXQY6AcgASgLMg8ucGIuQ3BwRmVhdHVyZXNSA2NwcA", [file_google_protobuf_descriptor]); +/** + * Describes the message pb.CppFeatures. + * Use `create(CppFeaturesSchema)` to create a new message. + */ +export const CppFeaturesSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_cpp_features, 0); +/** + * @generated from enum pb.CppFeatures.StringType + */ +export var CppFeatures_StringType; +(function (CppFeatures_StringType) { + /** + * @generated from enum value: STRING_TYPE_UNKNOWN = 0; + */ + CppFeatures_StringType[CppFeatures_StringType["STRING_TYPE_UNKNOWN"] = 0] = "STRING_TYPE_UNKNOWN"; + /** + * @generated from enum value: VIEW = 1; + */ + CppFeatures_StringType[CppFeatures_StringType["VIEW"] = 1] = "VIEW"; + /** + * @generated from enum value: CORD = 2; + */ + CppFeatures_StringType[CppFeatures_StringType["CORD"] = 2] = "CORD"; + /** + * @generated from enum value: STRING = 3; + */ + CppFeatures_StringType[CppFeatures_StringType["STRING"] = 3] = "STRING"; +})(CppFeatures_StringType || (CppFeatures_StringType = {})); +/** + * Describes the enum pb.CppFeatures.StringType. + */ +export const CppFeatures_StringTypeSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_cpp_features, 0, 0); +/** + * @generated from extension: optional pb.CppFeatures cpp = 1000; + */ +export const cpp = /*@__PURE__*/ extDesc(file_google_protobuf_cpp_features, 0); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/descriptor_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/descriptor_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e40bcfced58785ce6c6b2bfdf4e99c62d483d18e --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/descriptor_pb.d.ts @@ -0,0 +1,4119 @@ +import type { GenEnum, GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/descriptor.proto. + */ +export declare const file_google_protobuf_descriptor: GenFile; +/** + * The protocol compiler can output a FileDescriptorSet containing the .proto + * files it parses. + * + * @generated from message google.protobuf.FileDescriptorSet + */ +export type FileDescriptorSet = Message<"google.protobuf.FileDescriptorSet"> & { + /** + * @generated from field: repeated google.protobuf.FileDescriptorProto file = 1; + */ + file: FileDescriptorProto[]; +}; +/** + * The protocol compiler can output a FileDescriptorSet containing the .proto + * files it parses. + * + * @generated from message google.protobuf.FileDescriptorSet + */ +export type FileDescriptorSetJson = { + /** + * @generated from field: repeated google.protobuf.FileDescriptorProto file = 1; + */ + file?: FileDescriptorProtoJson[]; +}; +/** + * Describes the message google.protobuf.FileDescriptorSet. + * Use `create(FileDescriptorSetSchema)` to create a new message. + */ +export declare const FileDescriptorSetSchema: GenMessage; +/** + * Describes a complete .proto file. + * + * @generated from message google.protobuf.FileDescriptorProto + */ +export type FileDescriptorProto = Message<"google.protobuf.FileDescriptorProto"> & { + /** + * file name, relative to root of source tree + * + * @generated from field: optional string name = 1; + */ + name: string; + /** + * e.g. "foo", "foo.bar", etc. + * + * @generated from field: optional string package = 2; + */ + package: string; + /** + * Names of files imported by this file. + * + * @generated from field: repeated string dependency = 3; + */ + dependency: string[]; + /** + * Indexes of the public imported files in the dependency list above. + * + * @generated from field: repeated int32 public_dependency = 10; + */ + publicDependency: number[]; + /** + * Indexes of the weak imported files in the dependency list. + * For Google-internal migration only. Do not use. + * + * @generated from field: repeated int32 weak_dependency = 11; + */ + weakDependency: number[]; + /** + * Names of files imported by this file purely for the purpose of providing + * option extensions. These are excluded from the dependency list above. + * + * @generated from field: repeated string option_dependency = 15; + */ + optionDependency: string[]; + /** + * All top-level definitions in this file. + * + * @generated from field: repeated google.protobuf.DescriptorProto message_type = 4; + */ + messageType: DescriptorProto[]; + /** + * @generated from field: repeated google.protobuf.EnumDescriptorProto enum_type = 5; + */ + enumType: EnumDescriptorProto[]; + /** + * @generated from field: repeated google.protobuf.ServiceDescriptorProto service = 6; + */ + service: ServiceDescriptorProto[]; + /** + * @generated from field: repeated google.protobuf.FieldDescriptorProto extension = 7; + */ + extension: FieldDescriptorProto[]; + /** + * @generated from field: optional google.protobuf.FileOptions options = 8; + */ + options?: FileOptions; + /** + * This field contains optional information about the original source code. + * You may safely remove this entire field without harming runtime + * functionality of the descriptors -- the information is needed only by + * development tools. + * + * @generated from field: optional google.protobuf.SourceCodeInfo source_code_info = 9; + */ + sourceCodeInfo?: SourceCodeInfo; + /** + * The syntax of the proto file. + * The supported values are "proto2", "proto3", and "editions". + * + * If `edition` is present, this value must be "editions". + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional string syntax = 12; + */ + syntax: string; + /** + * The edition of the proto file. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.Edition edition = 14; + */ + edition: Edition; +}; +/** + * Describes a complete .proto file. + * + * @generated from message google.protobuf.FileDescriptorProto + */ +export type FileDescriptorProtoJson = { + /** + * file name, relative to root of source tree + * + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * e.g. "foo", "foo.bar", etc. + * + * @generated from field: optional string package = 2; + */ + package?: string; + /** + * Names of files imported by this file. + * + * @generated from field: repeated string dependency = 3; + */ + dependency?: string[]; + /** + * Indexes of the public imported files in the dependency list above. + * + * @generated from field: repeated int32 public_dependency = 10; + */ + publicDependency?: number[]; + /** + * Indexes of the weak imported files in the dependency list. + * For Google-internal migration only. Do not use. + * + * @generated from field: repeated int32 weak_dependency = 11; + */ + weakDependency?: number[]; + /** + * Names of files imported by this file purely for the purpose of providing + * option extensions. These are excluded from the dependency list above. + * + * @generated from field: repeated string option_dependency = 15; + */ + optionDependency?: string[]; + /** + * All top-level definitions in this file. + * + * @generated from field: repeated google.protobuf.DescriptorProto message_type = 4; + */ + messageType?: DescriptorProtoJson[]; + /** + * @generated from field: repeated google.protobuf.EnumDescriptorProto enum_type = 5; + */ + enumType?: EnumDescriptorProtoJson[]; + /** + * @generated from field: repeated google.protobuf.ServiceDescriptorProto service = 6; + */ + service?: ServiceDescriptorProtoJson[]; + /** + * @generated from field: repeated google.protobuf.FieldDescriptorProto extension = 7; + */ + extension?: FieldDescriptorProtoJson[]; + /** + * @generated from field: optional google.protobuf.FileOptions options = 8; + */ + options?: FileOptionsJson; + /** + * This field contains optional information about the original source code. + * You may safely remove this entire field without harming runtime + * functionality of the descriptors -- the information is needed only by + * development tools. + * + * @generated from field: optional google.protobuf.SourceCodeInfo source_code_info = 9; + */ + sourceCodeInfo?: SourceCodeInfoJson; + /** + * The syntax of the proto file. + * The supported values are "proto2", "proto3", and "editions". + * + * If `edition` is present, this value must be "editions". + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional string syntax = 12; + */ + syntax?: string; + /** + * The edition of the proto file. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.Edition edition = 14; + */ + edition?: EditionJson; +}; +/** + * Describes the message google.protobuf.FileDescriptorProto. + * Use `create(FileDescriptorProtoSchema)` to create a new message. + */ +export declare const FileDescriptorProtoSchema: GenMessage; +/** + * Describes a message type. + * + * @generated from message google.protobuf.DescriptorProto + */ +export type DescriptorProto = Message<"google.protobuf.DescriptorProto"> & { + /** + * @generated from field: optional string name = 1; + */ + name: string; + /** + * @generated from field: repeated google.protobuf.FieldDescriptorProto field = 2; + */ + field: FieldDescriptorProto[]; + /** + * @generated from field: repeated google.protobuf.FieldDescriptorProto extension = 6; + */ + extension: FieldDescriptorProto[]; + /** + * @generated from field: repeated google.protobuf.DescriptorProto nested_type = 3; + */ + nestedType: DescriptorProto[]; + /** + * @generated from field: repeated google.protobuf.EnumDescriptorProto enum_type = 4; + */ + enumType: EnumDescriptorProto[]; + /** + * @generated from field: repeated google.protobuf.DescriptorProto.ExtensionRange extension_range = 5; + */ + extensionRange: DescriptorProto_ExtensionRange[]; + /** + * @generated from field: repeated google.protobuf.OneofDescriptorProto oneof_decl = 8; + */ + oneofDecl: OneofDescriptorProto[]; + /** + * @generated from field: optional google.protobuf.MessageOptions options = 7; + */ + options?: MessageOptions; + /** + * @generated from field: repeated google.protobuf.DescriptorProto.ReservedRange reserved_range = 9; + */ + reservedRange: DescriptorProto_ReservedRange[]; + /** + * Reserved field names, which may not be used by fields in the same message. + * A given name may only be reserved once. + * + * @generated from field: repeated string reserved_name = 10; + */ + reservedName: string[]; + /** + * Support for `export` and `local` keywords on enums. + * + * @generated from field: optional google.protobuf.SymbolVisibility visibility = 11; + */ + visibility: SymbolVisibility; +}; +/** + * Describes a message type. + * + * @generated from message google.protobuf.DescriptorProto + */ +export type DescriptorProtoJson = { + /** + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * @generated from field: repeated google.protobuf.FieldDescriptorProto field = 2; + */ + field?: FieldDescriptorProtoJson[]; + /** + * @generated from field: repeated google.protobuf.FieldDescriptorProto extension = 6; + */ + extension?: FieldDescriptorProtoJson[]; + /** + * @generated from field: repeated google.protobuf.DescriptorProto nested_type = 3; + */ + nestedType?: DescriptorProtoJson[]; + /** + * @generated from field: repeated google.protobuf.EnumDescriptorProto enum_type = 4; + */ + enumType?: EnumDescriptorProtoJson[]; + /** + * @generated from field: repeated google.protobuf.DescriptorProto.ExtensionRange extension_range = 5; + */ + extensionRange?: DescriptorProto_ExtensionRangeJson[]; + /** + * @generated from field: repeated google.protobuf.OneofDescriptorProto oneof_decl = 8; + */ + oneofDecl?: OneofDescriptorProtoJson[]; + /** + * @generated from field: optional google.protobuf.MessageOptions options = 7; + */ + options?: MessageOptionsJson; + /** + * @generated from field: repeated google.protobuf.DescriptorProto.ReservedRange reserved_range = 9; + */ + reservedRange?: DescriptorProto_ReservedRangeJson[]; + /** + * Reserved field names, which may not be used by fields in the same message. + * A given name may only be reserved once. + * + * @generated from field: repeated string reserved_name = 10; + */ + reservedName?: string[]; + /** + * Support for `export` and `local` keywords on enums. + * + * @generated from field: optional google.protobuf.SymbolVisibility visibility = 11; + */ + visibility?: SymbolVisibilityJson; +}; +/** + * Describes the message google.protobuf.DescriptorProto. + * Use `create(DescriptorProtoSchema)` to create a new message. + */ +export declare const DescriptorProtoSchema: GenMessage; +/** + * @generated from message google.protobuf.DescriptorProto.ExtensionRange + */ +export type DescriptorProto_ExtensionRange = Message<"google.protobuf.DescriptorProto.ExtensionRange"> & { + /** + * Inclusive. + * + * @generated from field: optional int32 start = 1; + */ + start: number; + /** + * Exclusive. + * + * @generated from field: optional int32 end = 2; + */ + end: number; + /** + * @generated from field: optional google.protobuf.ExtensionRangeOptions options = 3; + */ + options?: ExtensionRangeOptions; +}; +/** + * @generated from message google.protobuf.DescriptorProto.ExtensionRange + */ +export type DescriptorProto_ExtensionRangeJson = { + /** + * Inclusive. + * + * @generated from field: optional int32 start = 1; + */ + start?: number; + /** + * Exclusive. + * + * @generated from field: optional int32 end = 2; + */ + end?: number; + /** + * @generated from field: optional google.protobuf.ExtensionRangeOptions options = 3; + */ + options?: ExtensionRangeOptionsJson; +}; +/** + * Describes the message google.protobuf.DescriptorProto.ExtensionRange. + * Use `create(DescriptorProto_ExtensionRangeSchema)` to create a new message. + */ +export declare const DescriptorProto_ExtensionRangeSchema: GenMessage; +/** + * Range of reserved tag numbers. Reserved tag numbers may not be used by + * fields or extension ranges in the same message. Reserved ranges may + * not overlap. + * + * @generated from message google.protobuf.DescriptorProto.ReservedRange + */ +export type DescriptorProto_ReservedRange = Message<"google.protobuf.DescriptorProto.ReservedRange"> & { + /** + * Inclusive. + * + * @generated from field: optional int32 start = 1; + */ + start: number; + /** + * Exclusive. + * + * @generated from field: optional int32 end = 2; + */ + end: number; +}; +/** + * Range of reserved tag numbers. Reserved tag numbers may not be used by + * fields or extension ranges in the same message. Reserved ranges may + * not overlap. + * + * @generated from message google.protobuf.DescriptorProto.ReservedRange + */ +export type DescriptorProto_ReservedRangeJson = { + /** + * Inclusive. + * + * @generated from field: optional int32 start = 1; + */ + start?: number; + /** + * Exclusive. + * + * @generated from field: optional int32 end = 2; + */ + end?: number; +}; +/** + * Describes the message google.protobuf.DescriptorProto.ReservedRange. + * Use `create(DescriptorProto_ReservedRangeSchema)` to create a new message. + */ +export declare const DescriptorProto_ReservedRangeSchema: GenMessage; +/** + * @generated from message google.protobuf.ExtensionRangeOptions + */ +export type ExtensionRangeOptions = Message<"google.protobuf.ExtensionRangeOptions"> & { + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; + /** + * For external users: DO NOT USE. We are in the process of open sourcing + * extension declaration and executing internal cleanups before it can be + * used externally. + * + * @generated from field: repeated google.protobuf.ExtensionRangeOptions.Declaration declaration = 2; + */ + declaration: ExtensionRangeOptions_Declaration[]; + /** + * Any features defined in the specific edition. + * + * @generated from field: optional google.protobuf.FeatureSet features = 50; + */ + features?: FeatureSet; + /** + * The verification state of the range. + * TODO: flip the default to DECLARATION once all empty ranges + * are marked as UNVERIFIED. + * + * @generated from field: optional google.protobuf.ExtensionRangeOptions.VerificationState verification = 3 [default = UNVERIFIED]; + */ + verification: ExtensionRangeOptions_VerificationState; +}; +/** + * @generated from message google.protobuf.ExtensionRangeOptions + */ +export type ExtensionRangeOptionsJson = { + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; + /** + * For external users: DO NOT USE. We are in the process of open sourcing + * extension declaration and executing internal cleanups before it can be + * used externally. + * + * @generated from field: repeated google.protobuf.ExtensionRangeOptions.Declaration declaration = 2; + */ + declaration?: ExtensionRangeOptions_DeclarationJson[]; + /** + * Any features defined in the specific edition. + * + * @generated from field: optional google.protobuf.FeatureSet features = 50; + */ + features?: FeatureSetJson; + /** + * The verification state of the range. + * TODO: flip the default to DECLARATION once all empty ranges + * are marked as UNVERIFIED. + * + * @generated from field: optional google.protobuf.ExtensionRangeOptions.VerificationState verification = 3 [default = UNVERIFIED]; + */ + verification?: ExtensionRangeOptions_VerificationStateJson; +}; +/** + * Describes the message google.protobuf.ExtensionRangeOptions. + * Use `create(ExtensionRangeOptionsSchema)` to create a new message. + */ +export declare const ExtensionRangeOptionsSchema: GenMessage; +/** + * @generated from message google.protobuf.ExtensionRangeOptions.Declaration + */ +export type ExtensionRangeOptions_Declaration = Message<"google.protobuf.ExtensionRangeOptions.Declaration"> & { + /** + * The extension number declared within the extension range. + * + * @generated from field: optional int32 number = 1; + */ + number: number; + /** + * The fully-qualified name of the extension field. There must be a leading + * dot in front of the full name. + * + * @generated from field: optional string full_name = 2; + */ + fullName: string; + /** + * The fully-qualified type name of the extension field. Unlike + * Metadata.type, Declaration.type must have a leading dot for messages + * and enums. + * + * @generated from field: optional string type = 3; + */ + type: string; + /** + * If true, indicates that the number is reserved in the extension range, + * and any extension field with the number will fail to compile. Set this + * when a declared extension field is deleted. + * + * @generated from field: optional bool reserved = 5; + */ + reserved: boolean; + /** + * If true, indicates that the extension must be defined as repeated. + * Otherwise the extension must be defined as optional. + * + * @generated from field: optional bool repeated = 6; + */ + repeated: boolean; +}; +/** + * @generated from message google.protobuf.ExtensionRangeOptions.Declaration + */ +export type ExtensionRangeOptions_DeclarationJson = { + /** + * The extension number declared within the extension range. + * + * @generated from field: optional int32 number = 1; + */ + number?: number; + /** + * The fully-qualified name of the extension field. There must be a leading + * dot in front of the full name. + * + * @generated from field: optional string full_name = 2; + */ + fullName?: string; + /** + * The fully-qualified type name of the extension field. Unlike + * Metadata.type, Declaration.type must have a leading dot for messages + * and enums. + * + * @generated from field: optional string type = 3; + */ + type?: string; + /** + * If true, indicates that the number is reserved in the extension range, + * and any extension field with the number will fail to compile. Set this + * when a declared extension field is deleted. + * + * @generated from field: optional bool reserved = 5; + */ + reserved?: boolean; + /** + * If true, indicates that the extension must be defined as repeated. + * Otherwise the extension must be defined as optional. + * + * @generated from field: optional bool repeated = 6; + */ + repeated?: boolean; +}; +/** + * Describes the message google.protobuf.ExtensionRangeOptions.Declaration. + * Use `create(ExtensionRangeOptions_DeclarationSchema)` to create a new message. + */ +export declare const ExtensionRangeOptions_DeclarationSchema: GenMessage; +/** + * The verification state of the extension range. + * + * @generated from enum google.protobuf.ExtensionRangeOptions.VerificationState + */ +export declare enum ExtensionRangeOptions_VerificationState { + /** + * All the extensions of the range must be declared. + * + * @generated from enum value: DECLARATION = 0; + */ + DECLARATION = 0, + /** + * @generated from enum value: UNVERIFIED = 1; + */ + UNVERIFIED = 1 +} +/** + * The verification state of the extension range. + * + * @generated from enum google.protobuf.ExtensionRangeOptions.VerificationState + */ +export type ExtensionRangeOptions_VerificationStateJson = "DECLARATION" | "UNVERIFIED"; +/** + * Describes the enum google.protobuf.ExtensionRangeOptions.VerificationState. + */ +export declare const ExtensionRangeOptions_VerificationStateSchema: GenEnum; +/** + * Describes a field within a message. + * + * @generated from message google.protobuf.FieldDescriptorProto + */ +export type FieldDescriptorProto = Message<"google.protobuf.FieldDescriptorProto"> & { + /** + * @generated from field: optional string name = 1; + */ + name: string; + /** + * @generated from field: optional int32 number = 3; + */ + number: number; + /** + * @generated from field: optional google.protobuf.FieldDescriptorProto.Label label = 4; + */ + label: FieldDescriptorProto_Label; + /** + * If type_name is set, this need not be set. If both this and type_name + * are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. + * + * @generated from field: optional google.protobuf.FieldDescriptorProto.Type type = 5; + */ + type: FieldDescriptorProto_Type; + /** + * For message and enum types, this is the name of the type. If the name + * starts with a '.', it is fully-qualified. Otherwise, C++-like scoping + * rules are used to find the type (i.e. first the nested types within this + * message are searched, then within the parent, on up to the root + * namespace). + * + * @generated from field: optional string type_name = 6; + */ + typeName: string; + /** + * For extensions, this is the name of the type being extended. It is + * resolved in the same manner as type_name. + * + * @generated from field: optional string extendee = 2; + */ + extendee: string; + /** + * For numeric types, contains the original text representation of the value. + * For booleans, "true" or "false". + * For strings, contains the default text contents (not escaped in any way). + * For bytes, contains the C escaped value. All bytes >= 128 are escaped. + * + * @generated from field: optional string default_value = 7; + */ + defaultValue: string; + /** + * If set, gives the index of a oneof in the containing type's oneof_decl + * list. This field is a member of that oneof. + * + * @generated from field: optional int32 oneof_index = 9; + */ + oneofIndex: number; + /** + * JSON name of this field. The value is set by protocol compiler. If the + * user has set a "json_name" option on this field, that option's value + * will be used. Otherwise, it's deduced from the field's name by converting + * it to camelCase. + * + * @generated from field: optional string json_name = 10; + */ + jsonName: string; + /** + * @generated from field: optional google.protobuf.FieldOptions options = 8; + */ + options?: FieldOptions; + /** + * If true, this is a proto3 "optional". When a proto3 field is optional, it + * tracks presence regardless of field type. + * + * When proto3_optional is true, this field must belong to a oneof to signal + * to old proto3 clients that presence is tracked for this field. This oneof + * is known as a "synthetic" oneof, and this field must be its sole member + * (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs + * exist in the descriptor only, and do not generate any API. Synthetic oneofs + * must be ordered after all "real" oneofs. + * + * For message fields, proto3_optional doesn't create any semantic change, + * since non-repeated message fields always track presence. However it still + * indicates the semantic detail of whether the user wrote "optional" or not. + * This can be useful for round-tripping the .proto file. For consistency we + * give message fields a synthetic oneof also, even though it is not required + * to track presence. This is especially important because the parser can't + * tell if a field is a message or an enum, so it must always create a + * synthetic oneof. + * + * Proto2 optional fields do not set this flag, because they already indicate + * optional with `LABEL_OPTIONAL`. + * + * @generated from field: optional bool proto3_optional = 17; + */ + proto3Optional: boolean; +}; +/** + * Describes a field within a message. + * + * @generated from message google.protobuf.FieldDescriptorProto + */ +export type FieldDescriptorProtoJson = { + /** + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * @generated from field: optional int32 number = 3; + */ + number?: number; + /** + * @generated from field: optional google.protobuf.FieldDescriptorProto.Label label = 4; + */ + label?: FieldDescriptorProto_LabelJson; + /** + * If type_name is set, this need not be set. If both this and type_name + * are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. + * + * @generated from field: optional google.protobuf.FieldDescriptorProto.Type type = 5; + */ + type?: FieldDescriptorProto_TypeJson; + /** + * For message and enum types, this is the name of the type. If the name + * starts with a '.', it is fully-qualified. Otherwise, C++-like scoping + * rules are used to find the type (i.e. first the nested types within this + * message are searched, then within the parent, on up to the root + * namespace). + * + * @generated from field: optional string type_name = 6; + */ + typeName?: string; + /** + * For extensions, this is the name of the type being extended. It is + * resolved in the same manner as type_name. + * + * @generated from field: optional string extendee = 2; + */ + extendee?: string; + /** + * For numeric types, contains the original text representation of the value. + * For booleans, "true" or "false". + * For strings, contains the default text contents (not escaped in any way). + * For bytes, contains the C escaped value. All bytes >= 128 are escaped. + * + * @generated from field: optional string default_value = 7; + */ + defaultValue?: string; + /** + * If set, gives the index of a oneof in the containing type's oneof_decl + * list. This field is a member of that oneof. + * + * @generated from field: optional int32 oneof_index = 9; + */ + oneofIndex?: number; + /** + * JSON name of this field. The value is set by protocol compiler. If the + * user has set a "json_name" option on this field, that option's value + * will be used. Otherwise, it's deduced from the field's name by converting + * it to camelCase. + * + * @generated from field: optional string json_name = 10; + */ + jsonName?: string; + /** + * @generated from field: optional google.protobuf.FieldOptions options = 8; + */ + options?: FieldOptionsJson; + /** + * If true, this is a proto3 "optional". When a proto3 field is optional, it + * tracks presence regardless of field type. + * + * When proto3_optional is true, this field must belong to a oneof to signal + * to old proto3 clients that presence is tracked for this field. This oneof + * is known as a "synthetic" oneof, and this field must be its sole member + * (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs + * exist in the descriptor only, and do not generate any API. Synthetic oneofs + * must be ordered after all "real" oneofs. + * + * For message fields, proto3_optional doesn't create any semantic change, + * since non-repeated message fields always track presence. However it still + * indicates the semantic detail of whether the user wrote "optional" or not. + * This can be useful for round-tripping the .proto file. For consistency we + * give message fields a synthetic oneof also, even though it is not required + * to track presence. This is especially important because the parser can't + * tell if a field is a message or an enum, so it must always create a + * synthetic oneof. + * + * Proto2 optional fields do not set this flag, because they already indicate + * optional with `LABEL_OPTIONAL`. + * + * @generated from field: optional bool proto3_optional = 17; + */ + proto3Optional?: boolean; +}; +/** + * Describes the message google.protobuf.FieldDescriptorProto. + * Use `create(FieldDescriptorProtoSchema)` to create a new message. + */ +export declare const FieldDescriptorProtoSchema: GenMessage; +/** + * @generated from enum google.protobuf.FieldDescriptorProto.Type + */ +export declare enum FieldDescriptorProto_Type { + /** + * 0 is reserved for errors. + * Order is weird for historical reasons. + * + * @generated from enum value: TYPE_DOUBLE = 1; + */ + DOUBLE = 1, + /** + * @generated from enum value: TYPE_FLOAT = 2; + */ + FLOAT = 2, + /** + * Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + * negative values are likely. + * + * @generated from enum value: TYPE_INT64 = 3; + */ + INT64 = 3, + /** + * @generated from enum value: TYPE_UINT64 = 4; + */ + UINT64 = 4, + /** + * Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + * negative values are likely. + * + * @generated from enum value: TYPE_INT32 = 5; + */ + INT32 = 5, + /** + * @generated from enum value: TYPE_FIXED64 = 6; + */ + FIXED64 = 6, + /** + * @generated from enum value: TYPE_FIXED32 = 7; + */ + FIXED32 = 7, + /** + * @generated from enum value: TYPE_BOOL = 8; + */ + BOOL = 8, + /** + * @generated from enum value: TYPE_STRING = 9; + */ + STRING = 9, + /** + * Tag-delimited aggregate. + * Group type is deprecated and not supported after google.protobuf. However, Proto3 + * implementations should still be able to parse the group wire format and + * treat group fields as unknown fields. In Editions, the group wire format + * can be enabled via the `message_encoding` feature. + * + * @generated from enum value: TYPE_GROUP = 10; + */ + GROUP = 10, + /** + * Length-delimited aggregate. + * + * @generated from enum value: TYPE_MESSAGE = 11; + */ + MESSAGE = 11, + /** + * New in version 2. + * + * @generated from enum value: TYPE_BYTES = 12; + */ + BYTES = 12, + /** + * @generated from enum value: TYPE_UINT32 = 13; + */ + UINT32 = 13, + /** + * @generated from enum value: TYPE_ENUM = 14; + */ + ENUM = 14, + /** + * @generated from enum value: TYPE_SFIXED32 = 15; + */ + SFIXED32 = 15, + /** + * @generated from enum value: TYPE_SFIXED64 = 16; + */ + SFIXED64 = 16, + /** + * Uses ZigZag encoding. + * + * @generated from enum value: TYPE_SINT32 = 17; + */ + SINT32 = 17, + /** + * Uses ZigZag encoding. + * + * @generated from enum value: TYPE_SINT64 = 18; + */ + SINT64 = 18 +} +/** + * @generated from enum google.protobuf.FieldDescriptorProto.Type + */ +export type FieldDescriptorProto_TypeJson = "TYPE_DOUBLE" | "TYPE_FLOAT" | "TYPE_INT64" | "TYPE_UINT64" | "TYPE_INT32" | "TYPE_FIXED64" | "TYPE_FIXED32" | "TYPE_BOOL" | "TYPE_STRING" | "TYPE_GROUP" | "TYPE_MESSAGE" | "TYPE_BYTES" | "TYPE_UINT32" | "TYPE_ENUM" | "TYPE_SFIXED32" | "TYPE_SFIXED64" | "TYPE_SINT32" | "TYPE_SINT64"; +/** + * Describes the enum google.protobuf.FieldDescriptorProto.Type. + */ +export declare const FieldDescriptorProto_TypeSchema: GenEnum; +/** + * @generated from enum google.protobuf.FieldDescriptorProto.Label + */ +export declare enum FieldDescriptorProto_Label { + /** + * 0 is reserved for errors + * + * @generated from enum value: LABEL_OPTIONAL = 1; + */ + OPTIONAL = 1, + /** + * @generated from enum value: LABEL_REPEATED = 3; + */ + REPEATED = 3, + /** + * The required label is only allowed in google.protobuf. In proto3 and Editions + * it's explicitly prohibited. In Editions, the `field_presence` feature + * can be used to get this behavior. + * + * @generated from enum value: LABEL_REQUIRED = 2; + */ + REQUIRED = 2 +} +/** + * @generated from enum google.protobuf.FieldDescriptorProto.Label + */ +export type FieldDescriptorProto_LabelJson = "LABEL_OPTIONAL" | "LABEL_REPEATED" | "LABEL_REQUIRED"; +/** + * Describes the enum google.protobuf.FieldDescriptorProto.Label. + */ +export declare const FieldDescriptorProto_LabelSchema: GenEnum; +/** + * Describes a oneof. + * + * @generated from message google.protobuf.OneofDescriptorProto + */ +export type OneofDescriptorProto = Message<"google.protobuf.OneofDescriptorProto"> & { + /** + * @generated from field: optional string name = 1; + */ + name: string; + /** + * @generated from field: optional google.protobuf.OneofOptions options = 2; + */ + options?: OneofOptions; +}; +/** + * Describes a oneof. + * + * @generated from message google.protobuf.OneofDescriptorProto + */ +export type OneofDescriptorProtoJson = { + /** + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * @generated from field: optional google.protobuf.OneofOptions options = 2; + */ + options?: OneofOptionsJson; +}; +/** + * Describes the message google.protobuf.OneofDescriptorProto. + * Use `create(OneofDescriptorProtoSchema)` to create a new message. + */ +export declare const OneofDescriptorProtoSchema: GenMessage; +/** + * Describes an enum type. + * + * @generated from message google.protobuf.EnumDescriptorProto + */ +export type EnumDescriptorProto = Message<"google.protobuf.EnumDescriptorProto"> & { + /** + * @generated from field: optional string name = 1; + */ + name: string; + /** + * @generated from field: repeated google.protobuf.EnumValueDescriptorProto value = 2; + */ + value: EnumValueDescriptorProto[]; + /** + * @generated from field: optional google.protobuf.EnumOptions options = 3; + */ + options?: EnumOptions; + /** + * Range of reserved numeric values. Reserved numeric values may not be used + * by enum values in the same enum declaration. Reserved ranges may not + * overlap. + * + * @generated from field: repeated google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4; + */ + reservedRange: EnumDescriptorProto_EnumReservedRange[]; + /** + * Reserved enum value names, which may not be reused. A given name may only + * be reserved once. + * + * @generated from field: repeated string reserved_name = 5; + */ + reservedName: string[]; + /** + * Support for `export` and `local` keywords on enums. + * + * @generated from field: optional google.protobuf.SymbolVisibility visibility = 6; + */ + visibility: SymbolVisibility; +}; +/** + * Describes an enum type. + * + * @generated from message google.protobuf.EnumDescriptorProto + */ +export type EnumDescriptorProtoJson = { + /** + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * @generated from field: repeated google.protobuf.EnumValueDescriptorProto value = 2; + */ + value?: EnumValueDescriptorProtoJson[]; + /** + * @generated from field: optional google.protobuf.EnumOptions options = 3; + */ + options?: EnumOptionsJson; + /** + * Range of reserved numeric values. Reserved numeric values may not be used + * by enum values in the same enum declaration. Reserved ranges may not + * overlap. + * + * @generated from field: repeated google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4; + */ + reservedRange?: EnumDescriptorProto_EnumReservedRangeJson[]; + /** + * Reserved enum value names, which may not be reused. A given name may only + * be reserved once. + * + * @generated from field: repeated string reserved_name = 5; + */ + reservedName?: string[]; + /** + * Support for `export` and `local` keywords on enums. + * + * @generated from field: optional google.protobuf.SymbolVisibility visibility = 6; + */ + visibility?: SymbolVisibilityJson; +}; +/** + * Describes the message google.protobuf.EnumDescriptorProto. + * Use `create(EnumDescriptorProtoSchema)` to create a new message. + */ +export declare const EnumDescriptorProtoSchema: GenMessage; +/** + * Range of reserved numeric values. Reserved values may not be used by + * entries in the same enum. Reserved ranges may not overlap. + * + * Note that this is distinct from DescriptorProto.ReservedRange in that it + * is inclusive such that it can appropriately represent the entire int32 + * domain. + * + * @generated from message google.protobuf.EnumDescriptorProto.EnumReservedRange + */ +export type EnumDescriptorProto_EnumReservedRange = Message<"google.protobuf.EnumDescriptorProto.EnumReservedRange"> & { + /** + * Inclusive. + * + * @generated from field: optional int32 start = 1; + */ + start: number; + /** + * Inclusive. + * + * @generated from field: optional int32 end = 2; + */ + end: number; +}; +/** + * Range of reserved numeric values. Reserved values may not be used by + * entries in the same enum. Reserved ranges may not overlap. + * + * Note that this is distinct from DescriptorProto.ReservedRange in that it + * is inclusive such that it can appropriately represent the entire int32 + * domain. + * + * @generated from message google.protobuf.EnumDescriptorProto.EnumReservedRange + */ +export type EnumDescriptorProto_EnumReservedRangeJson = { + /** + * Inclusive. + * + * @generated from field: optional int32 start = 1; + */ + start?: number; + /** + * Inclusive. + * + * @generated from field: optional int32 end = 2; + */ + end?: number; +}; +/** + * Describes the message google.protobuf.EnumDescriptorProto.EnumReservedRange. + * Use `create(EnumDescriptorProto_EnumReservedRangeSchema)` to create a new message. + */ +export declare const EnumDescriptorProto_EnumReservedRangeSchema: GenMessage; +/** + * Describes a value within an enum. + * + * @generated from message google.protobuf.EnumValueDescriptorProto + */ +export type EnumValueDescriptorProto = Message<"google.protobuf.EnumValueDescriptorProto"> & { + /** + * @generated from field: optional string name = 1; + */ + name: string; + /** + * @generated from field: optional int32 number = 2; + */ + number: number; + /** + * @generated from field: optional google.protobuf.EnumValueOptions options = 3; + */ + options?: EnumValueOptions; +}; +/** + * Describes a value within an enum. + * + * @generated from message google.protobuf.EnumValueDescriptorProto + */ +export type EnumValueDescriptorProtoJson = { + /** + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * @generated from field: optional int32 number = 2; + */ + number?: number; + /** + * @generated from field: optional google.protobuf.EnumValueOptions options = 3; + */ + options?: EnumValueOptionsJson; +}; +/** + * Describes the message google.protobuf.EnumValueDescriptorProto. + * Use `create(EnumValueDescriptorProtoSchema)` to create a new message. + */ +export declare const EnumValueDescriptorProtoSchema: GenMessage; +/** + * Describes a service. + * + * @generated from message google.protobuf.ServiceDescriptorProto + */ +export type ServiceDescriptorProto = Message<"google.protobuf.ServiceDescriptorProto"> & { + /** + * @generated from field: optional string name = 1; + */ + name: string; + /** + * @generated from field: repeated google.protobuf.MethodDescriptorProto method = 2; + */ + method: MethodDescriptorProto[]; + /** + * @generated from field: optional google.protobuf.ServiceOptions options = 3; + */ + options?: ServiceOptions; +}; +/** + * Describes a service. + * + * @generated from message google.protobuf.ServiceDescriptorProto + */ +export type ServiceDescriptorProtoJson = { + /** + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * @generated from field: repeated google.protobuf.MethodDescriptorProto method = 2; + */ + method?: MethodDescriptorProtoJson[]; + /** + * @generated from field: optional google.protobuf.ServiceOptions options = 3; + */ + options?: ServiceOptionsJson; +}; +/** + * Describes the message google.protobuf.ServiceDescriptorProto. + * Use `create(ServiceDescriptorProtoSchema)` to create a new message. + */ +export declare const ServiceDescriptorProtoSchema: GenMessage; +/** + * Describes a method of a service. + * + * @generated from message google.protobuf.MethodDescriptorProto + */ +export type MethodDescriptorProto = Message<"google.protobuf.MethodDescriptorProto"> & { + /** + * @generated from field: optional string name = 1; + */ + name: string; + /** + * Input and output type names. These are resolved in the same way as + * FieldDescriptorProto.type_name, but must refer to a message type. + * + * @generated from field: optional string input_type = 2; + */ + inputType: string; + /** + * @generated from field: optional string output_type = 3; + */ + outputType: string; + /** + * @generated from field: optional google.protobuf.MethodOptions options = 4; + */ + options?: MethodOptions; + /** + * Identifies if client streams multiple client messages + * + * @generated from field: optional bool client_streaming = 5 [default = false]; + */ + clientStreaming: boolean; + /** + * Identifies if server streams multiple server messages + * + * @generated from field: optional bool server_streaming = 6 [default = false]; + */ + serverStreaming: boolean; +}; +/** + * Describes a method of a service. + * + * @generated from message google.protobuf.MethodDescriptorProto + */ +export type MethodDescriptorProtoJson = { + /** + * @generated from field: optional string name = 1; + */ + name?: string; + /** + * Input and output type names. These are resolved in the same way as + * FieldDescriptorProto.type_name, but must refer to a message type. + * + * @generated from field: optional string input_type = 2; + */ + inputType?: string; + /** + * @generated from field: optional string output_type = 3; + */ + outputType?: string; + /** + * @generated from field: optional google.protobuf.MethodOptions options = 4; + */ + options?: MethodOptionsJson; + /** + * Identifies if client streams multiple client messages + * + * @generated from field: optional bool client_streaming = 5 [default = false]; + */ + clientStreaming?: boolean; + /** + * Identifies if server streams multiple server messages + * + * @generated from field: optional bool server_streaming = 6 [default = false]; + */ + serverStreaming?: boolean; +}; +/** + * Describes the message google.protobuf.MethodDescriptorProto. + * Use `create(MethodDescriptorProtoSchema)` to create a new message. + */ +export declare const MethodDescriptorProtoSchema: GenMessage; +/** + * @generated from message google.protobuf.FileOptions + */ +export type FileOptions = Message<"google.protobuf.FileOptions"> & { + /** + * Sets the Java package where classes generated from this .proto will be + * placed. By default, the proto package is used, but this is often + * inappropriate because proto packages do not normally start with backwards + * domain names. + * + * @generated from field: optional string java_package = 1; + */ + javaPackage: string; + /** + * Controls the name of the wrapper Java class generated for the .proto file. + * That class will always contain the .proto file's getDescriptor() method as + * well as any top-level extensions defined in the .proto file. + * If java_multiple_files is disabled, then all the other classes from the + * .proto file will be nested inside the single wrapper outer class. + * + * @generated from field: optional string java_outer_classname = 8; + */ + javaOuterClassname: string; + /** + * If enabled, then the Java code generator will generate a separate .java + * file for each top-level message, enum, and service defined in the .proto + * file. Thus, these types will *not* be nested inside the wrapper class + * named by java_outer_classname. However, the wrapper class will still be + * generated to contain the file's getDescriptor() method as well as any + * top-level extensions defined in the file. + * + * @generated from field: optional bool java_multiple_files = 10 [default = false]; + */ + javaMultipleFiles: boolean; + /** + * This option does nothing. + * + * @generated from field: optional bool java_generate_equals_and_hash = 20 [deprecated = true]; + * @deprecated + */ + javaGenerateEqualsAndHash: boolean; + /** + * A proto2 file can set this to true to opt in to UTF-8 checking for Java, + * which will throw an exception if invalid UTF-8 is parsed from the wire or + * assigned to a string field. + * + * TODO: clarify exactly what kinds of field types this option + * applies to, and update these docs accordingly. + * + * Proto3 files already perform these checks. Setting the option explicitly to + * false has no effect: it cannot be used to opt proto3 files out of UTF-8 + * checks. + * + * @generated from field: optional bool java_string_check_utf8 = 27 [default = false]; + */ + javaStringCheckUtf8: boolean; + /** + * @generated from field: optional google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED]; + */ + optimizeFor: FileOptions_OptimizeMode; + /** + * Sets the Go package where structs generated from this .proto will be + * placed. If omitted, the Go package will be derived from the following: + * - The basename of the package import path, if provided. + * - Otherwise, the package statement in the .proto file, if present. + * - Otherwise, the basename of the .proto file, without extension. + * + * @generated from field: optional string go_package = 11; + */ + goPackage: string; + /** + * Should generic services be generated in each language? "Generic" services + * are not specific to any particular RPC system. They are generated by the + * main code generators in each language (without additional plugins). + * Generic services were the only kind of service generation supported by + * early versions of google.protobuf. + * + * Generic services are now considered deprecated in favor of using plugins + * that generate code specific to your particular RPC system. Therefore, + * these default to false. Old code which depends on generic services should + * explicitly set them to true. + * + * @generated from field: optional bool cc_generic_services = 16 [default = false]; + */ + ccGenericServices: boolean; + /** + * @generated from field: optional bool java_generic_services = 17 [default = false]; + */ + javaGenericServices: boolean; + /** + * @generated from field: optional bool py_generic_services = 18 [default = false]; + */ + pyGenericServices: boolean; + /** + * Is this file deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for everything in the file, or it will be completely ignored; in the very + * least, this is a formalization for deprecating files. + * + * @generated from field: optional bool deprecated = 23 [default = false]; + */ + deprecated: boolean; + /** + * Enables the use of arenas for the proto messages in this file. This applies + * only to generated classes for C++. + * + * @generated from field: optional bool cc_enable_arenas = 31 [default = true]; + */ + ccEnableArenas: boolean; + /** + * Sets the objective c class prefix which is prepended to all objective c + * generated classes from this .proto. There is no default. + * + * @generated from field: optional string objc_class_prefix = 36; + */ + objcClassPrefix: string; + /** + * Namespace for generated classes; defaults to the package. + * + * @generated from field: optional string csharp_namespace = 37; + */ + csharpNamespace: string; + /** + * By default Swift generators will take the proto package and CamelCase it + * replacing '.' with underscore and use that to prefix the types/symbols + * defined. When this options is provided, they will use this value instead + * to prefix the types/symbols defined. + * + * @generated from field: optional string swift_prefix = 39; + */ + swiftPrefix: string; + /** + * Sets the php class prefix which is prepended to all php generated classes + * from this .proto. Default is empty. + * + * @generated from field: optional string php_class_prefix = 40; + */ + phpClassPrefix: string; + /** + * Use this option to change the namespace of php generated classes. Default + * is empty. When this option is empty, the package name will be used for + * determining the namespace. + * + * @generated from field: optional string php_namespace = 41; + */ + phpNamespace: string; + /** + * Use this option to change the namespace of php generated metadata classes. + * Default is empty. When this option is empty, the proto file name will be + * used for determining the namespace. + * + * @generated from field: optional string php_metadata_namespace = 44; + */ + phpMetadataNamespace: string; + /** + * Use this option to change the package of ruby generated classes. Default + * is empty. When this option is not set, the package name will be used for + * determining the ruby package. + * + * @generated from field: optional string ruby_package = 45; + */ + rubyPackage: string; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 50; + */ + features?: FeatureSet; + /** + * The parser stores options it doesn't recognize here. + * See the documentation for the "Options" section above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; +}; +/** + * @generated from message google.protobuf.FileOptions + */ +export type FileOptionsJson = { + /** + * Sets the Java package where classes generated from this .proto will be + * placed. By default, the proto package is used, but this is often + * inappropriate because proto packages do not normally start with backwards + * domain names. + * + * @generated from field: optional string java_package = 1; + */ + javaPackage?: string; + /** + * Controls the name of the wrapper Java class generated for the .proto file. + * That class will always contain the .proto file's getDescriptor() method as + * well as any top-level extensions defined in the .proto file. + * If java_multiple_files is disabled, then all the other classes from the + * .proto file will be nested inside the single wrapper outer class. + * + * @generated from field: optional string java_outer_classname = 8; + */ + javaOuterClassname?: string; + /** + * If enabled, then the Java code generator will generate a separate .java + * file for each top-level message, enum, and service defined in the .proto + * file. Thus, these types will *not* be nested inside the wrapper class + * named by java_outer_classname. However, the wrapper class will still be + * generated to contain the file's getDescriptor() method as well as any + * top-level extensions defined in the file. + * + * @generated from field: optional bool java_multiple_files = 10 [default = false]; + */ + javaMultipleFiles?: boolean; + /** + * This option does nothing. + * + * @generated from field: optional bool java_generate_equals_and_hash = 20 [deprecated = true]; + * @deprecated + */ + javaGenerateEqualsAndHash?: boolean; + /** + * A proto2 file can set this to true to opt in to UTF-8 checking for Java, + * which will throw an exception if invalid UTF-8 is parsed from the wire or + * assigned to a string field. + * + * TODO: clarify exactly what kinds of field types this option + * applies to, and update these docs accordingly. + * + * Proto3 files already perform these checks. Setting the option explicitly to + * false has no effect: it cannot be used to opt proto3 files out of UTF-8 + * checks. + * + * @generated from field: optional bool java_string_check_utf8 = 27 [default = false]; + */ + javaStringCheckUtf8?: boolean; + /** + * @generated from field: optional google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED]; + */ + optimizeFor?: FileOptions_OptimizeModeJson; + /** + * Sets the Go package where structs generated from this .proto will be + * placed. If omitted, the Go package will be derived from the following: + * - The basename of the package import path, if provided. + * - Otherwise, the package statement in the .proto file, if present. + * - Otherwise, the basename of the .proto file, without extension. + * + * @generated from field: optional string go_package = 11; + */ + goPackage?: string; + /** + * Should generic services be generated in each language? "Generic" services + * are not specific to any particular RPC system. They are generated by the + * main code generators in each language (without additional plugins). + * Generic services were the only kind of service generation supported by + * early versions of google.protobuf. + * + * Generic services are now considered deprecated in favor of using plugins + * that generate code specific to your particular RPC system. Therefore, + * these default to false. Old code which depends on generic services should + * explicitly set them to true. + * + * @generated from field: optional bool cc_generic_services = 16 [default = false]; + */ + ccGenericServices?: boolean; + /** + * @generated from field: optional bool java_generic_services = 17 [default = false]; + */ + javaGenericServices?: boolean; + /** + * @generated from field: optional bool py_generic_services = 18 [default = false]; + */ + pyGenericServices?: boolean; + /** + * Is this file deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for everything in the file, or it will be completely ignored; in the very + * least, this is a formalization for deprecating files. + * + * @generated from field: optional bool deprecated = 23 [default = false]; + */ + deprecated?: boolean; + /** + * Enables the use of arenas for the proto messages in this file. This applies + * only to generated classes for C++. + * + * @generated from field: optional bool cc_enable_arenas = 31 [default = true]; + */ + ccEnableArenas?: boolean; + /** + * Sets the objective c class prefix which is prepended to all objective c + * generated classes from this .proto. There is no default. + * + * @generated from field: optional string objc_class_prefix = 36; + */ + objcClassPrefix?: string; + /** + * Namespace for generated classes; defaults to the package. + * + * @generated from field: optional string csharp_namespace = 37; + */ + csharpNamespace?: string; + /** + * By default Swift generators will take the proto package and CamelCase it + * replacing '.' with underscore and use that to prefix the types/symbols + * defined. When this options is provided, they will use this value instead + * to prefix the types/symbols defined. + * + * @generated from field: optional string swift_prefix = 39; + */ + swiftPrefix?: string; + /** + * Sets the php class prefix which is prepended to all php generated classes + * from this .proto. Default is empty. + * + * @generated from field: optional string php_class_prefix = 40; + */ + phpClassPrefix?: string; + /** + * Use this option to change the namespace of php generated classes. Default + * is empty. When this option is empty, the package name will be used for + * determining the namespace. + * + * @generated from field: optional string php_namespace = 41; + */ + phpNamespace?: string; + /** + * Use this option to change the namespace of php generated metadata classes. + * Default is empty. When this option is empty, the proto file name will be + * used for determining the namespace. + * + * @generated from field: optional string php_metadata_namespace = 44; + */ + phpMetadataNamespace?: string; + /** + * Use this option to change the package of ruby generated classes. Default + * is empty. When this option is not set, the package name will be used for + * determining the ruby package. + * + * @generated from field: optional string ruby_package = 45; + */ + rubyPackage?: string; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 50; + */ + features?: FeatureSetJson; + /** + * The parser stores options it doesn't recognize here. + * See the documentation for the "Options" section above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; +}; +/** + * Describes the message google.protobuf.FileOptions. + * Use `create(FileOptionsSchema)` to create a new message. + */ +export declare const FileOptionsSchema: GenMessage; +/** + * Generated classes can be optimized for speed or code size. + * + * @generated from enum google.protobuf.FileOptions.OptimizeMode + */ +export declare enum FileOptions_OptimizeMode { + /** + * Generate complete code for parsing, serialization, + * + * @generated from enum value: SPEED = 1; + */ + SPEED = 1, + /** + * etc. + * + * Use ReflectionOps to implement these methods. + * + * @generated from enum value: CODE_SIZE = 2; + */ + CODE_SIZE = 2, + /** + * Generate code using MessageLite and the lite runtime. + * + * @generated from enum value: LITE_RUNTIME = 3; + */ + LITE_RUNTIME = 3 +} +/** + * Generated classes can be optimized for speed or code size. + * + * @generated from enum google.protobuf.FileOptions.OptimizeMode + */ +export type FileOptions_OptimizeModeJson = "SPEED" | "CODE_SIZE" | "LITE_RUNTIME"; +/** + * Describes the enum google.protobuf.FileOptions.OptimizeMode. + */ +export declare const FileOptions_OptimizeModeSchema: GenEnum; +/** + * @generated from message google.protobuf.MessageOptions + */ +export type MessageOptions = Message<"google.protobuf.MessageOptions"> & { + /** + * Set true to use the old proto1 MessageSet wire format for extensions. + * This is provided for backwards-compatibility with the MessageSet wire + * format. You should not use this for any other reason: It's less + * efficient, has fewer features, and is more complicated. + * + * The message must be defined exactly as follows: + * message Foo { + * option message_set_wire_format = true; + * extensions 4 to max; + * } + * Note that the message cannot have any defined fields; MessageSets only + * have extensions. + * + * All extensions of your type must be singular messages; e.g. they cannot + * be int32s, enums, or repeated messages. + * + * Because this is an option, the above two restrictions are not enforced by + * the protocol compiler. + * + * @generated from field: optional bool message_set_wire_format = 1 [default = false]; + */ + messageSetWireFormat: boolean; + /** + * Disables the generation of the standard "descriptor()" accessor, which can + * conflict with a field of the same name. This is meant to make migration + * from proto1 easier; new code should avoid fields named "descriptor". + * + * @generated from field: optional bool no_standard_descriptor_accessor = 2 [default = false]; + */ + noStandardDescriptorAccessor: boolean; + /** + * Is this message deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the message, or it will be completely ignored; in the very least, + * this is a formalization for deprecating messages. + * + * @generated from field: optional bool deprecated = 3 [default = false]; + */ + deprecated: boolean; + /** + * Whether the message is an automatically generated map entry type for the + * maps field. + * + * For maps fields: + * map map_field = 1; + * The parsed descriptor looks like: + * message MapFieldEntry { + * option map_entry = true; + * optional KeyType key = 1; + * optional ValueType value = 2; + * } + * repeated MapFieldEntry map_field = 1; + * + * Implementations may choose not to generate the map_entry=true message, but + * use a native map in the target language to hold the keys and values. + * The reflection APIs in such implementations still need to work as + * if the field is a repeated message field. + * + * NOTE: Do not set the option in .proto files. Always use the maps syntax + * instead. The option should only be implicitly set by the proto compiler + * parser. + * + * @generated from field: optional bool map_entry = 7; + */ + mapEntry: boolean; + /** + * Enable the legacy handling of JSON field name conflicts. This lowercases + * and strips underscored from the fields before comparison in proto3 only. + * The new behavior takes `json_name` into account and applies to proto2 as + * well. + * + * This should only be used as a temporary measure against broken builds due + * to the change in behavior for JSON field name conflicts. + * + * TODO This is legacy behavior we plan to remove once downstream + * teams have had time to migrate. + * + * @generated from field: optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true]; + * @deprecated + */ + deprecatedLegacyJsonFieldConflicts: boolean; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 12; + */ + features?: FeatureSet; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; +}; +/** + * @generated from message google.protobuf.MessageOptions + */ +export type MessageOptionsJson = { + /** + * Set true to use the old proto1 MessageSet wire format for extensions. + * This is provided for backwards-compatibility with the MessageSet wire + * format. You should not use this for any other reason: It's less + * efficient, has fewer features, and is more complicated. + * + * The message must be defined exactly as follows: + * message Foo { + * option message_set_wire_format = true; + * extensions 4 to max; + * } + * Note that the message cannot have any defined fields; MessageSets only + * have extensions. + * + * All extensions of your type must be singular messages; e.g. they cannot + * be int32s, enums, or repeated messages. + * + * Because this is an option, the above two restrictions are not enforced by + * the protocol compiler. + * + * @generated from field: optional bool message_set_wire_format = 1 [default = false]; + */ + messageSetWireFormat?: boolean; + /** + * Disables the generation of the standard "descriptor()" accessor, which can + * conflict with a field of the same name. This is meant to make migration + * from proto1 easier; new code should avoid fields named "descriptor". + * + * @generated from field: optional bool no_standard_descriptor_accessor = 2 [default = false]; + */ + noStandardDescriptorAccessor?: boolean; + /** + * Is this message deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the message, or it will be completely ignored; in the very least, + * this is a formalization for deprecating messages. + * + * @generated from field: optional bool deprecated = 3 [default = false]; + */ + deprecated?: boolean; + /** + * Whether the message is an automatically generated map entry type for the + * maps field. + * + * For maps fields: + * map map_field = 1; + * The parsed descriptor looks like: + * message MapFieldEntry { + * option map_entry = true; + * optional KeyType key = 1; + * optional ValueType value = 2; + * } + * repeated MapFieldEntry map_field = 1; + * + * Implementations may choose not to generate the map_entry=true message, but + * use a native map in the target language to hold the keys and values. + * The reflection APIs in such implementations still need to work as + * if the field is a repeated message field. + * + * NOTE: Do not set the option in .proto files. Always use the maps syntax + * instead. The option should only be implicitly set by the proto compiler + * parser. + * + * @generated from field: optional bool map_entry = 7; + */ + mapEntry?: boolean; + /** + * Enable the legacy handling of JSON field name conflicts. This lowercases + * and strips underscored from the fields before comparison in proto3 only. + * The new behavior takes `json_name` into account and applies to proto2 as + * well. + * + * This should only be used as a temporary measure against broken builds due + * to the change in behavior for JSON field name conflicts. + * + * TODO This is legacy behavior we plan to remove once downstream + * teams have had time to migrate. + * + * @generated from field: optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true]; + * @deprecated + */ + deprecatedLegacyJsonFieldConflicts?: boolean; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 12; + */ + features?: FeatureSetJson; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; +}; +/** + * Describes the message google.protobuf.MessageOptions. + * Use `create(MessageOptionsSchema)` to create a new message. + */ +export declare const MessageOptionsSchema: GenMessage; +/** + * @generated from message google.protobuf.FieldOptions + */ +export type FieldOptions = Message<"google.protobuf.FieldOptions"> & { + /** + * NOTE: ctype is deprecated. Use `features.(pb.cpp).string_type` instead. + * The ctype option instructs the C++ code generator to use a different + * representation of the field than it normally would. See the specific + * options below. This option is only implemented to support use of + * [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of + * type "bytes" in the open source release. + * TODO: make ctype actually deprecated. + * + * @generated from field: optional google.protobuf.FieldOptions.CType ctype = 1 [default = STRING]; + */ + ctype: FieldOptions_CType; + /** + * The packed option can be enabled for repeated primitive fields to enable + * a more efficient representation on the wire. Rather than repeatedly + * writing the tag and type for each element, the entire array is encoded as + * a single length-delimited blob. In proto3, only explicit setting it to + * false will avoid using packed encoding. This option is prohibited in + * Editions, but the `repeated_field_encoding` feature can be used to control + * the behavior. + * + * @generated from field: optional bool packed = 2; + */ + packed: boolean; + /** + * The jstype option determines the JavaScript type used for values of the + * field. The option is permitted only for 64 bit integral and fixed types + * (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING + * is represented as JavaScript string, which avoids loss of precision that + * can happen when a large value is converted to a floating point JavaScript. + * Specifying JS_NUMBER for the jstype causes the generated JavaScript code to + * use the JavaScript "number" type. The behavior of the default option + * JS_NORMAL is implementation dependent. + * + * This option is an enum to permit additional types to be added, e.g. + * goog.math.Integer. + * + * @generated from field: optional google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL]; + */ + jstype: FieldOptions_JSType; + /** + * Should this field be parsed lazily? Lazy applies only to message-type + * fields. It means that when the outer message is initially parsed, the + * inner message's contents will not be parsed but instead stored in encoded + * form. The inner message will actually be parsed when it is first accessed. + * + * This is only a hint. Implementations are free to choose whether to use + * eager or lazy parsing regardless of the value of this option. However, + * setting this option true suggests that the protocol author believes that + * using lazy parsing on this field is worth the additional bookkeeping + * overhead typically needed to implement it. + * + * This option does not affect the public interface of any generated code; + * all method signatures remain the same. Furthermore, thread-safety of the + * interface is not affected by this option; const methods remain safe to + * call from multiple threads concurrently, while non-const methods continue + * to require exclusive access. + * + * Note that lazy message fields are still eagerly verified to check + * ill-formed wireformat or missing required fields. Calling IsInitialized() + * on the outer message would fail if the inner message has missing required + * fields. Failed verification would result in parsing failure (except when + * uninitialized messages are acceptable). + * + * @generated from field: optional bool lazy = 5 [default = false]; + */ + lazy: boolean; + /** + * unverified_lazy does no correctness checks on the byte stream. This should + * only be used where lazy with verification is prohibitive for performance + * reasons. + * + * @generated from field: optional bool unverified_lazy = 15 [default = false]; + */ + unverifiedLazy: boolean; + /** + * Is this field deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for accessors, or it will be completely ignored; in the very least, this + * is a formalization for deprecating fields. + * + * @generated from field: optional bool deprecated = 3 [default = false]; + */ + deprecated: boolean; + /** + * For Google-internal migration only. Do not use. + * + * @generated from field: optional bool weak = 10 [default = false]; + */ + weak: boolean; + /** + * Indicate that the field value should not be printed out when using debug + * formats, e.g. when the field contains sensitive credentials. + * + * @generated from field: optional bool debug_redact = 16 [default = false]; + */ + debugRedact: boolean; + /** + * @generated from field: optional google.protobuf.FieldOptions.OptionRetention retention = 17; + */ + retention: FieldOptions_OptionRetention; + /** + * @generated from field: repeated google.protobuf.FieldOptions.OptionTargetType targets = 19; + */ + targets: FieldOptions_OptionTargetType[]; + /** + * @generated from field: repeated google.protobuf.FieldOptions.EditionDefault edition_defaults = 20; + */ + editionDefaults: FieldOptions_EditionDefault[]; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 21; + */ + features?: FeatureSet; + /** + * @generated from field: optional google.protobuf.FieldOptions.FeatureSupport feature_support = 22; + */ + featureSupport?: FieldOptions_FeatureSupport; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; +}; +/** + * @generated from message google.protobuf.FieldOptions + */ +export type FieldOptionsJson = { + /** + * NOTE: ctype is deprecated. Use `features.(pb.cpp).string_type` instead. + * The ctype option instructs the C++ code generator to use a different + * representation of the field than it normally would. See the specific + * options below. This option is only implemented to support use of + * [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of + * type "bytes" in the open source release. + * TODO: make ctype actually deprecated. + * + * @generated from field: optional google.protobuf.FieldOptions.CType ctype = 1 [default = STRING]; + */ + ctype?: FieldOptions_CTypeJson; + /** + * The packed option can be enabled for repeated primitive fields to enable + * a more efficient representation on the wire. Rather than repeatedly + * writing the tag and type for each element, the entire array is encoded as + * a single length-delimited blob. In proto3, only explicit setting it to + * false will avoid using packed encoding. This option is prohibited in + * Editions, but the `repeated_field_encoding` feature can be used to control + * the behavior. + * + * @generated from field: optional bool packed = 2; + */ + packed?: boolean; + /** + * The jstype option determines the JavaScript type used for values of the + * field. The option is permitted only for 64 bit integral and fixed types + * (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING + * is represented as JavaScript string, which avoids loss of precision that + * can happen when a large value is converted to a floating point JavaScript. + * Specifying JS_NUMBER for the jstype causes the generated JavaScript code to + * use the JavaScript "number" type. The behavior of the default option + * JS_NORMAL is implementation dependent. + * + * This option is an enum to permit additional types to be added, e.g. + * goog.math.Integer. + * + * @generated from field: optional google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL]; + */ + jstype?: FieldOptions_JSTypeJson; + /** + * Should this field be parsed lazily? Lazy applies only to message-type + * fields. It means that when the outer message is initially parsed, the + * inner message's contents will not be parsed but instead stored in encoded + * form. The inner message will actually be parsed when it is first accessed. + * + * This is only a hint. Implementations are free to choose whether to use + * eager or lazy parsing regardless of the value of this option. However, + * setting this option true suggests that the protocol author believes that + * using lazy parsing on this field is worth the additional bookkeeping + * overhead typically needed to implement it. + * + * This option does not affect the public interface of any generated code; + * all method signatures remain the same. Furthermore, thread-safety of the + * interface is not affected by this option; const methods remain safe to + * call from multiple threads concurrently, while non-const methods continue + * to require exclusive access. + * + * Note that lazy message fields are still eagerly verified to check + * ill-formed wireformat or missing required fields. Calling IsInitialized() + * on the outer message would fail if the inner message has missing required + * fields. Failed verification would result in parsing failure (except when + * uninitialized messages are acceptable). + * + * @generated from field: optional bool lazy = 5 [default = false]; + */ + lazy?: boolean; + /** + * unverified_lazy does no correctness checks on the byte stream. This should + * only be used where lazy with verification is prohibitive for performance + * reasons. + * + * @generated from field: optional bool unverified_lazy = 15 [default = false]; + */ + unverifiedLazy?: boolean; + /** + * Is this field deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for accessors, or it will be completely ignored; in the very least, this + * is a formalization for deprecating fields. + * + * @generated from field: optional bool deprecated = 3 [default = false]; + */ + deprecated?: boolean; + /** + * For Google-internal migration only. Do not use. + * + * @generated from field: optional bool weak = 10 [default = false]; + */ + weak?: boolean; + /** + * Indicate that the field value should not be printed out when using debug + * formats, e.g. when the field contains sensitive credentials. + * + * @generated from field: optional bool debug_redact = 16 [default = false]; + */ + debugRedact?: boolean; + /** + * @generated from field: optional google.protobuf.FieldOptions.OptionRetention retention = 17; + */ + retention?: FieldOptions_OptionRetentionJson; + /** + * @generated from field: repeated google.protobuf.FieldOptions.OptionTargetType targets = 19; + */ + targets?: FieldOptions_OptionTargetTypeJson[]; + /** + * @generated from field: repeated google.protobuf.FieldOptions.EditionDefault edition_defaults = 20; + */ + editionDefaults?: FieldOptions_EditionDefaultJson[]; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 21; + */ + features?: FeatureSetJson; + /** + * @generated from field: optional google.protobuf.FieldOptions.FeatureSupport feature_support = 22; + */ + featureSupport?: FieldOptions_FeatureSupportJson; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; +}; +/** + * Describes the message google.protobuf.FieldOptions. + * Use `create(FieldOptionsSchema)` to create a new message. + */ +export declare const FieldOptionsSchema: GenMessage; +/** + * @generated from message google.protobuf.FieldOptions.EditionDefault + */ +export type FieldOptions_EditionDefault = Message<"google.protobuf.FieldOptions.EditionDefault"> & { + /** + * @generated from field: optional google.protobuf.Edition edition = 3; + */ + edition: Edition; + /** + * Textproto value. + * + * @generated from field: optional string value = 2; + */ + value: string; +}; +/** + * @generated from message google.protobuf.FieldOptions.EditionDefault + */ +export type FieldOptions_EditionDefaultJson = { + /** + * @generated from field: optional google.protobuf.Edition edition = 3; + */ + edition?: EditionJson; + /** + * Textproto value. + * + * @generated from field: optional string value = 2; + */ + value?: string; +}; +/** + * Describes the message google.protobuf.FieldOptions.EditionDefault. + * Use `create(FieldOptions_EditionDefaultSchema)` to create a new message. + */ +export declare const FieldOptions_EditionDefaultSchema: GenMessage; +/** + * Information about the support window of a feature. + * + * @generated from message google.protobuf.FieldOptions.FeatureSupport + */ +export type FieldOptions_FeatureSupport = Message<"google.protobuf.FieldOptions.FeatureSupport"> & { + /** + * The edition that this feature was first available in. In editions + * earlier than this one, the default assigned to EDITION_LEGACY will be + * used, and proto files will not be able to override it. + * + * @generated from field: optional google.protobuf.Edition edition_introduced = 1; + */ + editionIntroduced: Edition; + /** + * The edition this feature becomes deprecated in. Using this after this + * edition may trigger warnings. + * + * @generated from field: optional google.protobuf.Edition edition_deprecated = 2; + */ + editionDeprecated: Edition; + /** + * The deprecation warning text if this feature is used after the edition it + * was marked deprecated in. + * + * @generated from field: optional string deprecation_warning = 3; + */ + deprecationWarning: string; + /** + * The edition this feature is no longer available in. In editions after + * this one, the last default assigned will be used, and proto files will + * not be able to override it. + * + * @generated from field: optional google.protobuf.Edition edition_removed = 4; + */ + editionRemoved: Edition; +}; +/** + * Information about the support window of a feature. + * + * @generated from message google.protobuf.FieldOptions.FeatureSupport + */ +export type FieldOptions_FeatureSupportJson = { + /** + * The edition that this feature was first available in. In editions + * earlier than this one, the default assigned to EDITION_LEGACY will be + * used, and proto files will not be able to override it. + * + * @generated from field: optional google.protobuf.Edition edition_introduced = 1; + */ + editionIntroduced?: EditionJson; + /** + * The edition this feature becomes deprecated in. Using this after this + * edition may trigger warnings. + * + * @generated from field: optional google.protobuf.Edition edition_deprecated = 2; + */ + editionDeprecated?: EditionJson; + /** + * The deprecation warning text if this feature is used after the edition it + * was marked deprecated in. + * + * @generated from field: optional string deprecation_warning = 3; + */ + deprecationWarning?: string; + /** + * The edition this feature is no longer available in. In editions after + * this one, the last default assigned will be used, and proto files will + * not be able to override it. + * + * @generated from field: optional google.protobuf.Edition edition_removed = 4; + */ + editionRemoved?: EditionJson; +}; +/** + * Describes the message google.protobuf.FieldOptions.FeatureSupport. + * Use `create(FieldOptions_FeatureSupportSchema)` to create a new message. + */ +export declare const FieldOptions_FeatureSupportSchema: GenMessage; +/** + * @generated from enum google.protobuf.FieldOptions.CType + */ +export declare enum FieldOptions_CType { + /** + * Default mode. + * + * @generated from enum value: STRING = 0; + */ + STRING = 0, + /** + * The option [ctype=CORD] may be applied to a non-repeated field of type + * "bytes". It indicates that in C++, the data should be stored in a Cord + * instead of a string. For very large strings, this may reduce memory + * fragmentation. It may also allow better performance when parsing from a + * Cord, or when parsing with aliasing enabled, as the parsed Cord may then + * alias the original buffer. + * + * @generated from enum value: CORD = 1; + */ + CORD = 1, + /** + * @generated from enum value: STRING_PIECE = 2; + */ + STRING_PIECE = 2 +} +/** + * @generated from enum google.protobuf.FieldOptions.CType + */ +export type FieldOptions_CTypeJson = "STRING" | "CORD" | "STRING_PIECE"; +/** + * Describes the enum google.protobuf.FieldOptions.CType. + */ +export declare const FieldOptions_CTypeSchema: GenEnum; +/** + * @generated from enum google.protobuf.FieldOptions.JSType + */ +export declare enum FieldOptions_JSType { + /** + * Use the default type. + * + * @generated from enum value: JS_NORMAL = 0; + */ + JS_NORMAL = 0, + /** + * Use JavaScript strings. + * + * @generated from enum value: JS_STRING = 1; + */ + JS_STRING = 1, + /** + * Use JavaScript numbers. + * + * @generated from enum value: JS_NUMBER = 2; + */ + JS_NUMBER = 2 +} +/** + * @generated from enum google.protobuf.FieldOptions.JSType + */ +export type FieldOptions_JSTypeJson = "JS_NORMAL" | "JS_STRING" | "JS_NUMBER"; +/** + * Describes the enum google.protobuf.FieldOptions.JSType. + */ +export declare const FieldOptions_JSTypeSchema: GenEnum; +/** + * If set to RETENTION_SOURCE, the option will be omitted from the binary. + * + * @generated from enum google.protobuf.FieldOptions.OptionRetention + */ +export declare enum FieldOptions_OptionRetention { + /** + * @generated from enum value: RETENTION_UNKNOWN = 0; + */ + RETENTION_UNKNOWN = 0, + /** + * @generated from enum value: RETENTION_RUNTIME = 1; + */ + RETENTION_RUNTIME = 1, + /** + * @generated from enum value: RETENTION_SOURCE = 2; + */ + RETENTION_SOURCE = 2 +} +/** + * If set to RETENTION_SOURCE, the option will be omitted from the binary. + * + * @generated from enum google.protobuf.FieldOptions.OptionRetention + */ +export type FieldOptions_OptionRetentionJson = "RETENTION_UNKNOWN" | "RETENTION_RUNTIME" | "RETENTION_SOURCE"; +/** + * Describes the enum google.protobuf.FieldOptions.OptionRetention. + */ +export declare const FieldOptions_OptionRetentionSchema: GenEnum; +/** + * This indicates the types of entities that the field may apply to when used + * as an option. If it is unset, then the field may be freely used as an + * option on any kind of entity. + * + * @generated from enum google.protobuf.FieldOptions.OptionTargetType + */ +export declare enum FieldOptions_OptionTargetType { + /** + * @generated from enum value: TARGET_TYPE_UNKNOWN = 0; + */ + TARGET_TYPE_UNKNOWN = 0, + /** + * @generated from enum value: TARGET_TYPE_FILE = 1; + */ + TARGET_TYPE_FILE = 1, + /** + * @generated from enum value: TARGET_TYPE_EXTENSION_RANGE = 2; + */ + TARGET_TYPE_EXTENSION_RANGE = 2, + /** + * @generated from enum value: TARGET_TYPE_MESSAGE = 3; + */ + TARGET_TYPE_MESSAGE = 3, + /** + * @generated from enum value: TARGET_TYPE_FIELD = 4; + */ + TARGET_TYPE_FIELD = 4, + /** + * @generated from enum value: TARGET_TYPE_ONEOF = 5; + */ + TARGET_TYPE_ONEOF = 5, + /** + * @generated from enum value: TARGET_TYPE_ENUM = 6; + */ + TARGET_TYPE_ENUM = 6, + /** + * @generated from enum value: TARGET_TYPE_ENUM_ENTRY = 7; + */ + TARGET_TYPE_ENUM_ENTRY = 7, + /** + * @generated from enum value: TARGET_TYPE_SERVICE = 8; + */ + TARGET_TYPE_SERVICE = 8, + /** + * @generated from enum value: TARGET_TYPE_METHOD = 9; + */ + TARGET_TYPE_METHOD = 9 +} +/** + * This indicates the types of entities that the field may apply to when used + * as an option. If it is unset, then the field may be freely used as an + * option on any kind of entity. + * + * @generated from enum google.protobuf.FieldOptions.OptionTargetType + */ +export type FieldOptions_OptionTargetTypeJson = "TARGET_TYPE_UNKNOWN" | "TARGET_TYPE_FILE" | "TARGET_TYPE_EXTENSION_RANGE" | "TARGET_TYPE_MESSAGE" | "TARGET_TYPE_FIELD" | "TARGET_TYPE_ONEOF" | "TARGET_TYPE_ENUM" | "TARGET_TYPE_ENUM_ENTRY" | "TARGET_TYPE_SERVICE" | "TARGET_TYPE_METHOD"; +/** + * Describes the enum google.protobuf.FieldOptions.OptionTargetType. + */ +export declare const FieldOptions_OptionTargetTypeSchema: GenEnum; +/** + * @generated from message google.protobuf.OneofOptions + */ +export type OneofOptions = Message<"google.protobuf.OneofOptions"> & { + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 1; + */ + features?: FeatureSet; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; +}; +/** + * @generated from message google.protobuf.OneofOptions + */ +export type OneofOptionsJson = { + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 1; + */ + features?: FeatureSetJson; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; +}; +/** + * Describes the message google.protobuf.OneofOptions. + * Use `create(OneofOptionsSchema)` to create a new message. + */ +export declare const OneofOptionsSchema: GenMessage; +/** + * @generated from message google.protobuf.EnumOptions + */ +export type EnumOptions = Message<"google.protobuf.EnumOptions"> & { + /** + * Set this option to true to allow mapping different tag names to the same + * value. + * + * @generated from field: optional bool allow_alias = 2; + */ + allowAlias: boolean; + /** + * Is this enum deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the enum, or it will be completely ignored; in the very least, this + * is a formalization for deprecating enums. + * + * @generated from field: optional bool deprecated = 3 [default = false]; + */ + deprecated: boolean; + /** + * Enable the legacy handling of JSON field name conflicts. This lowercases + * and strips underscored from the fields before comparison in proto3 only. + * The new behavior takes `json_name` into account and applies to proto2 as + * well. + * TODO Remove this legacy behavior once downstream teams have + * had time to migrate. + * + * @generated from field: optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true]; + * @deprecated + */ + deprecatedLegacyJsonFieldConflicts: boolean; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 7; + */ + features?: FeatureSet; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; +}; +/** + * @generated from message google.protobuf.EnumOptions + */ +export type EnumOptionsJson = { + /** + * Set this option to true to allow mapping different tag names to the same + * value. + * + * @generated from field: optional bool allow_alias = 2; + */ + allowAlias?: boolean; + /** + * Is this enum deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the enum, or it will be completely ignored; in the very least, this + * is a formalization for deprecating enums. + * + * @generated from field: optional bool deprecated = 3 [default = false]; + */ + deprecated?: boolean; + /** + * Enable the legacy handling of JSON field name conflicts. This lowercases + * and strips underscored from the fields before comparison in proto3 only. + * The new behavior takes `json_name` into account and applies to proto2 as + * well. + * TODO Remove this legacy behavior once downstream teams have + * had time to migrate. + * + * @generated from field: optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true]; + * @deprecated + */ + deprecatedLegacyJsonFieldConflicts?: boolean; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 7; + */ + features?: FeatureSetJson; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; +}; +/** + * Describes the message google.protobuf.EnumOptions. + * Use `create(EnumOptionsSchema)` to create a new message. + */ +export declare const EnumOptionsSchema: GenMessage; +/** + * @generated from message google.protobuf.EnumValueOptions + */ +export type EnumValueOptions = Message<"google.protobuf.EnumValueOptions"> & { + /** + * Is this enum value deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the enum value, or it will be completely ignored; in the very least, + * this is a formalization for deprecating enum values. + * + * @generated from field: optional bool deprecated = 1 [default = false]; + */ + deprecated: boolean; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 2; + */ + features?: FeatureSet; + /** + * Indicate that fields annotated with this enum value should not be printed + * out when using debug formats, e.g. when the field contains sensitive + * credentials. + * + * @generated from field: optional bool debug_redact = 3 [default = false]; + */ + debugRedact: boolean; + /** + * Information about the support window of a feature value. + * + * @generated from field: optional google.protobuf.FieldOptions.FeatureSupport feature_support = 4; + */ + featureSupport?: FieldOptions_FeatureSupport; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; +}; +/** + * @generated from message google.protobuf.EnumValueOptions + */ +export type EnumValueOptionsJson = { + /** + * Is this enum value deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the enum value, or it will be completely ignored; in the very least, + * this is a formalization for deprecating enum values. + * + * @generated from field: optional bool deprecated = 1 [default = false]; + */ + deprecated?: boolean; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 2; + */ + features?: FeatureSetJson; + /** + * Indicate that fields annotated with this enum value should not be printed + * out when using debug formats, e.g. when the field contains sensitive + * credentials. + * + * @generated from field: optional bool debug_redact = 3 [default = false]; + */ + debugRedact?: boolean; + /** + * Information about the support window of a feature value. + * + * @generated from field: optional google.protobuf.FieldOptions.FeatureSupport feature_support = 4; + */ + featureSupport?: FieldOptions_FeatureSupportJson; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; +}; +/** + * Describes the message google.protobuf.EnumValueOptions. + * Use `create(EnumValueOptionsSchema)` to create a new message. + */ +export declare const EnumValueOptionsSchema: GenMessage; +/** + * @generated from message google.protobuf.ServiceOptions + */ +export type ServiceOptions = Message<"google.protobuf.ServiceOptions"> & { + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 34; + */ + features?: FeatureSet; + /** + * Is this service deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the service, or it will be completely ignored; in the very least, + * this is a formalization for deprecating services. + * + * @generated from field: optional bool deprecated = 33 [default = false]; + */ + deprecated: boolean; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; +}; +/** + * @generated from message google.protobuf.ServiceOptions + */ +export type ServiceOptionsJson = { + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 34; + */ + features?: FeatureSetJson; + /** + * Is this service deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the service, or it will be completely ignored; in the very least, + * this is a formalization for deprecating services. + * + * @generated from field: optional bool deprecated = 33 [default = false]; + */ + deprecated?: boolean; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; +}; +/** + * Describes the message google.protobuf.ServiceOptions. + * Use `create(ServiceOptionsSchema)` to create a new message. + */ +export declare const ServiceOptionsSchema: GenMessage; +/** + * @generated from message google.protobuf.MethodOptions + */ +export type MethodOptions = Message<"google.protobuf.MethodOptions"> & { + /** + * Is this method deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the method, or it will be completely ignored; in the very least, + * this is a formalization for deprecating methods. + * + * @generated from field: optional bool deprecated = 33 [default = false]; + */ + deprecated: boolean; + /** + * @generated from field: optional google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN]; + */ + idempotencyLevel: MethodOptions_IdempotencyLevel; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 35; + */ + features?: FeatureSet; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption: UninterpretedOption[]; +}; +/** + * @generated from message google.protobuf.MethodOptions + */ +export type MethodOptionsJson = { + /** + * Is this method deprecated? + * Depending on the target platform, this can emit Deprecated annotations + * for the method, or it will be completely ignored; in the very least, + * this is a formalization for deprecating methods. + * + * @generated from field: optional bool deprecated = 33 [default = false]; + */ + deprecated?: boolean; + /** + * @generated from field: optional google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN]; + */ + idempotencyLevel?: MethodOptions_IdempotencyLevelJson; + /** + * Any features defined in the specific edition. + * WARNING: This field should only be used by protobuf plugins or special + * cases like the proto compiler. Other uses are discouraged and + * developers should rely on the protoreflect APIs for their client language. + * + * @generated from field: optional google.protobuf.FeatureSet features = 35; + */ + features?: FeatureSetJson; + /** + * The parser stores options it doesn't recognize here. See above. + * + * @generated from field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; + */ + uninterpretedOption?: UninterpretedOptionJson[]; +}; +/** + * Describes the message google.protobuf.MethodOptions. + * Use `create(MethodOptionsSchema)` to create a new message. + */ +export declare const MethodOptionsSchema: GenMessage; +/** + * Is this method side-effect-free (or safe in HTTP parlance), or idempotent, + * or neither? HTTP based RPC implementation may choose GET verb for safe + * methods, and PUT verb for idempotent methods instead of the default POST. + * + * @generated from enum google.protobuf.MethodOptions.IdempotencyLevel + */ +export declare enum MethodOptions_IdempotencyLevel { + /** + * @generated from enum value: IDEMPOTENCY_UNKNOWN = 0; + */ + IDEMPOTENCY_UNKNOWN = 0, + /** + * implies idempotent + * + * @generated from enum value: NO_SIDE_EFFECTS = 1; + */ + NO_SIDE_EFFECTS = 1, + /** + * idempotent, but may have side effects + * + * @generated from enum value: IDEMPOTENT = 2; + */ + IDEMPOTENT = 2 +} +/** + * Is this method side-effect-free (or safe in HTTP parlance), or idempotent, + * or neither? HTTP based RPC implementation may choose GET verb for safe + * methods, and PUT verb for idempotent methods instead of the default POST. + * + * @generated from enum google.protobuf.MethodOptions.IdempotencyLevel + */ +export type MethodOptions_IdempotencyLevelJson = "IDEMPOTENCY_UNKNOWN" | "NO_SIDE_EFFECTS" | "IDEMPOTENT"; +/** + * Describes the enum google.protobuf.MethodOptions.IdempotencyLevel. + */ +export declare const MethodOptions_IdempotencyLevelSchema: GenEnum; +/** + * A message representing a option the parser does not recognize. This only + * appears in options protos created by the compiler::Parser class. + * DescriptorPool resolves these when building Descriptor objects. Therefore, + * options protos in descriptor objects (e.g. returned by Descriptor::options(), + * or produced by Descriptor::CopyTo()) will never have UninterpretedOptions + * in them. + * + * @generated from message google.protobuf.UninterpretedOption + */ +export type UninterpretedOption = Message<"google.protobuf.UninterpretedOption"> & { + /** + * @generated from field: repeated google.protobuf.UninterpretedOption.NamePart name = 2; + */ + name: UninterpretedOption_NamePart[]; + /** + * The value of the uninterpreted option, in whatever type the tokenizer + * identified it as during parsing. Exactly one of these should be set. + * + * @generated from field: optional string identifier_value = 3; + */ + identifierValue: string; + /** + * @generated from field: optional uint64 positive_int_value = 4; + */ + positiveIntValue: bigint; + /** + * @generated from field: optional int64 negative_int_value = 5; + */ + negativeIntValue: bigint; + /** + * @generated from field: optional double double_value = 6; + */ + doubleValue: number; + /** + * @generated from field: optional bytes string_value = 7; + */ + stringValue: Uint8Array; + /** + * @generated from field: optional string aggregate_value = 8; + */ + aggregateValue: string; +}; +/** + * A message representing a option the parser does not recognize. This only + * appears in options protos created by the compiler::Parser class. + * DescriptorPool resolves these when building Descriptor objects. Therefore, + * options protos in descriptor objects (e.g. returned by Descriptor::options(), + * or produced by Descriptor::CopyTo()) will never have UninterpretedOptions + * in them. + * + * @generated from message google.protobuf.UninterpretedOption + */ +export type UninterpretedOptionJson = { + /** + * @generated from field: repeated google.protobuf.UninterpretedOption.NamePart name = 2; + */ + name?: UninterpretedOption_NamePartJson[]; + /** + * The value of the uninterpreted option, in whatever type the tokenizer + * identified it as during parsing. Exactly one of these should be set. + * + * @generated from field: optional string identifier_value = 3; + */ + identifierValue?: string; + /** + * @generated from field: optional uint64 positive_int_value = 4; + */ + positiveIntValue?: string; + /** + * @generated from field: optional int64 negative_int_value = 5; + */ + negativeIntValue?: string; + /** + * @generated from field: optional double double_value = 6; + */ + doubleValue?: number | "NaN" | "Infinity" | "-Infinity"; + /** + * @generated from field: optional bytes string_value = 7; + */ + stringValue?: string; + /** + * @generated from field: optional string aggregate_value = 8; + */ + aggregateValue?: string; +}; +/** + * Describes the message google.protobuf.UninterpretedOption. + * Use `create(UninterpretedOptionSchema)` to create a new message. + */ +export declare const UninterpretedOptionSchema: GenMessage; +/** + * The name of the uninterpreted option. Each string represents a segment in + * a dot-separated name. is_extension is true iff a segment represents an + * extension (denoted with parentheses in options specs in .proto files). + * E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents + * "foo.(bar.baz).moo". + * + * @generated from message google.protobuf.UninterpretedOption.NamePart + */ +export type UninterpretedOption_NamePart = Message<"google.protobuf.UninterpretedOption.NamePart"> & { + /** + * @generated from field: required string name_part = 1; + */ + namePart: string; + /** + * @generated from field: required bool is_extension = 2; + */ + isExtension: boolean; +}; +/** + * The name of the uninterpreted option. Each string represents a segment in + * a dot-separated name. is_extension is true iff a segment represents an + * extension (denoted with parentheses in options specs in .proto files). + * E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents + * "foo.(bar.baz).moo". + * + * @generated from message google.protobuf.UninterpretedOption.NamePart + */ +export type UninterpretedOption_NamePartJson = { + /** + * @generated from field: required string name_part = 1; + */ + namePart?: string; + /** + * @generated from field: required bool is_extension = 2; + */ + isExtension?: boolean; +}; +/** + * Describes the message google.protobuf.UninterpretedOption.NamePart. + * Use `create(UninterpretedOption_NamePartSchema)` to create a new message. + */ +export declare const UninterpretedOption_NamePartSchema: GenMessage; +/** + * TODO Enums in C++ gencode (and potentially other languages) are + * not well scoped. This means that each of the feature enums below can clash + * with each other. The short names we've chosen maximize call-site + * readability, but leave us very open to this scenario. A future feature will + * be designed and implemented to handle this, hopefully before we ever hit a + * conflict here. + * + * @generated from message google.protobuf.FeatureSet + */ +export type FeatureSet = Message<"google.protobuf.FeatureSet"> & { + /** + * @generated from field: optional google.protobuf.FeatureSet.FieldPresence field_presence = 1; + */ + fieldPresence: FeatureSet_FieldPresence; + /** + * @generated from field: optional google.protobuf.FeatureSet.EnumType enum_type = 2; + */ + enumType: FeatureSet_EnumType; + /** + * @generated from field: optional google.protobuf.FeatureSet.RepeatedFieldEncoding repeated_field_encoding = 3; + */ + repeatedFieldEncoding: FeatureSet_RepeatedFieldEncoding; + /** + * @generated from field: optional google.protobuf.FeatureSet.Utf8Validation utf8_validation = 4; + */ + utf8Validation: FeatureSet_Utf8Validation; + /** + * @generated from field: optional google.protobuf.FeatureSet.MessageEncoding message_encoding = 5; + */ + messageEncoding: FeatureSet_MessageEncoding; + /** + * @generated from field: optional google.protobuf.FeatureSet.JsonFormat json_format = 6; + */ + jsonFormat: FeatureSet_JsonFormat; + /** + * @generated from field: optional google.protobuf.FeatureSet.EnforceNamingStyle enforce_naming_style = 7; + */ + enforceNamingStyle: FeatureSet_EnforceNamingStyle; + /** + * @generated from field: optional google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility default_symbol_visibility = 8; + */ + defaultSymbolVisibility: FeatureSet_VisibilityFeature_DefaultSymbolVisibility; +}; +/** + * TODO Enums in C++ gencode (and potentially other languages) are + * not well scoped. This means that each of the feature enums below can clash + * with each other. The short names we've chosen maximize call-site + * readability, but leave us very open to this scenario. A future feature will + * be designed and implemented to handle this, hopefully before we ever hit a + * conflict here. + * + * @generated from message google.protobuf.FeatureSet + */ +export type FeatureSetJson = { + /** + * @generated from field: optional google.protobuf.FeatureSet.FieldPresence field_presence = 1; + */ + fieldPresence?: FeatureSet_FieldPresenceJson; + /** + * @generated from field: optional google.protobuf.FeatureSet.EnumType enum_type = 2; + */ + enumType?: FeatureSet_EnumTypeJson; + /** + * @generated from field: optional google.protobuf.FeatureSet.RepeatedFieldEncoding repeated_field_encoding = 3; + */ + repeatedFieldEncoding?: FeatureSet_RepeatedFieldEncodingJson; + /** + * @generated from field: optional google.protobuf.FeatureSet.Utf8Validation utf8_validation = 4; + */ + utf8Validation?: FeatureSet_Utf8ValidationJson; + /** + * @generated from field: optional google.protobuf.FeatureSet.MessageEncoding message_encoding = 5; + */ + messageEncoding?: FeatureSet_MessageEncodingJson; + /** + * @generated from field: optional google.protobuf.FeatureSet.JsonFormat json_format = 6; + */ + jsonFormat?: FeatureSet_JsonFormatJson; + /** + * @generated from field: optional google.protobuf.FeatureSet.EnforceNamingStyle enforce_naming_style = 7; + */ + enforceNamingStyle?: FeatureSet_EnforceNamingStyleJson; + /** + * @generated from field: optional google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility default_symbol_visibility = 8; + */ + defaultSymbolVisibility?: FeatureSet_VisibilityFeature_DefaultSymbolVisibilityJson; +}; +/** + * Describes the message google.protobuf.FeatureSet. + * Use `create(FeatureSetSchema)` to create a new message. + */ +export declare const FeatureSetSchema: GenMessage; +/** + * @generated from message google.protobuf.FeatureSet.VisibilityFeature + */ +export type FeatureSet_VisibilityFeature = Message<"google.protobuf.FeatureSet.VisibilityFeature"> & {}; +/** + * @generated from message google.protobuf.FeatureSet.VisibilityFeature + */ +export type FeatureSet_VisibilityFeatureJson = {}; +/** + * Describes the message google.protobuf.FeatureSet.VisibilityFeature. + * Use `create(FeatureSet_VisibilityFeatureSchema)` to create a new message. + */ +export declare const FeatureSet_VisibilityFeatureSchema: GenMessage; +/** + * @generated from enum google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility + */ +export declare enum FeatureSet_VisibilityFeature_DefaultSymbolVisibility { + /** + * @generated from enum value: DEFAULT_SYMBOL_VISIBILITY_UNKNOWN = 0; + */ + DEFAULT_SYMBOL_VISIBILITY_UNKNOWN = 0, + /** + * Default pre-EDITION_2024, all UNSET visibility are export. + * + * @generated from enum value: EXPORT_ALL = 1; + */ + EXPORT_ALL = 1, + /** + * All top-level symbols default to export, nested default to local. + * + * @generated from enum value: EXPORT_TOP_LEVEL = 2; + */ + EXPORT_TOP_LEVEL = 2, + /** + * All symbols default to local. + * + * @generated from enum value: LOCAL_ALL = 3; + */ + LOCAL_ALL = 3, + /** + * All symbols local by default. Nested types cannot be exported. + * With special case caveat for message { enum {} reserved 1 to max; } + * This is the recommended setting for new protos. + * + * @generated from enum value: STRICT = 4; + */ + STRICT = 4 +} +/** + * @generated from enum google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility + */ +export type FeatureSet_VisibilityFeature_DefaultSymbolVisibilityJson = "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN" | "EXPORT_ALL" | "EXPORT_TOP_LEVEL" | "LOCAL_ALL" | "STRICT"; +/** + * Describes the enum google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility. + */ +export declare const FeatureSet_VisibilityFeature_DefaultSymbolVisibilitySchema: GenEnum; +/** + * @generated from enum google.protobuf.FeatureSet.FieldPresence + */ +export declare enum FeatureSet_FieldPresence { + /** + * @generated from enum value: FIELD_PRESENCE_UNKNOWN = 0; + */ + FIELD_PRESENCE_UNKNOWN = 0, + /** + * @generated from enum value: EXPLICIT = 1; + */ + EXPLICIT = 1, + /** + * @generated from enum value: IMPLICIT = 2; + */ + IMPLICIT = 2, + /** + * @generated from enum value: LEGACY_REQUIRED = 3; + */ + LEGACY_REQUIRED = 3 +} +/** + * @generated from enum google.protobuf.FeatureSet.FieldPresence + */ +export type FeatureSet_FieldPresenceJson = "FIELD_PRESENCE_UNKNOWN" | "EXPLICIT" | "IMPLICIT" | "LEGACY_REQUIRED"; +/** + * Describes the enum google.protobuf.FeatureSet.FieldPresence. + */ +export declare const FeatureSet_FieldPresenceSchema: GenEnum; +/** + * @generated from enum google.protobuf.FeatureSet.EnumType + */ +export declare enum FeatureSet_EnumType { + /** + * @generated from enum value: ENUM_TYPE_UNKNOWN = 0; + */ + ENUM_TYPE_UNKNOWN = 0, + /** + * @generated from enum value: OPEN = 1; + */ + OPEN = 1, + /** + * @generated from enum value: CLOSED = 2; + */ + CLOSED = 2 +} +/** + * @generated from enum google.protobuf.FeatureSet.EnumType + */ +export type FeatureSet_EnumTypeJson = "ENUM_TYPE_UNKNOWN" | "OPEN" | "CLOSED"; +/** + * Describes the enum google.protobuf.FeatureSet.EnumType. + */ +export declare const FeatureSet_EnumTypeSchema: GenEnum; +/** + * @generated from enum google.protobuf.FeatureSet.RepeatedFieldEncoding + */ +export declare enum FeatureSet_RepeatedFieldEncoding { + /** + * @generated from enum value: REPEATED_FIELD_ENCODING_UNKNOWN = 0; + */ + REPEATED_FIELD_ENCODING_UNKNOWN = 0, + /** + * @generated from enum value: PACKED = 1; + */ + PACKED = 1, + /** + * @generated from enum value: EXPANDED = 2; + */ + EXPANDED = 2 +} +/** + * @generated from enum google.protobuf.FeatureSet.RepeatedFieldEncoding + */ +export type FeatureSet_RepeatedFieldEncodingJson = "REPEATED_FIELD_ENCODING_UNKNOWN" | "PACKED" | "EXPANDED"; +/** + * Describes the enum google.protobuf.FeatureSet.RepeatedFieldEncoding. + */ +export declare const FeatureSet_RepeatedFieldEncodingSchema: GenEnum; +/** + * @generated from enum google.protobuf.FeatureSet.Utf8Validation + */ +export declare enum FeatureSet_Utf8Validation { + /** + * @generated from enum value: UTF8_VALIDATION_UNKNOWN = 0; + */ + UTF8_VALIDATION_UNKNOWN = 0, + /** + * @generated from enum value: VERIFY = 2; + */ + VERIFY = 2, + /** + * @generated from enum value: NONE = 3; + */ + NONE = 3 +} +/** + * @generated from enum google.protobuf.FeatureSet.Utf8Validation + */ +export type FeatureSet_Utf8ValidationJson = "UTF8_VALIDATION_UNKNOWN" | "VERIFY" | "NONE"; +/** + * Describes the enum google.protobuf.FeatureSet.Utf8Validation. + */ +export declare const FeatureSet_Utf8ValidationSchema: GenEnum; +/** + * @generated from enum google.protobuf.FeatureSet.MessageEncoding + */ +export declare enum FeatureSet_MessageEncoding { + /** + * @generated from enum value: MESSAGE_ENCODING_UNKNOWN = 0; + */ + MESSAGE_ENCODING_UNKNOWN = 0, + /** + * @generated from enum value: LENGTH_PREFIXED = 1; + */ + LENGTH_PREFIXED = 1, + /** + * @generated from enum value: DELIMITED = 2; + */ + DELIMITED = 2 +} +/** + * @generated from enum google.protobuf.FeatureSet.MessageEncoding + */ +export type FeatureSet_MessageEncodingJson = "MESSAGE_ENCODING_UNKNOWN" | "LENGTH_PREFIXED" | "DELIMITED"; +/** + * Describes the enum google.protobuf.FeatureSet.MessageEncoding. + */ +export declare const FeatureSet_MessageEncodingSchema: GenEnum; +/** + * @generated from enum google.protobuf.FeatureSet.JsonFormat + */ +export declare enum FeatureSet_JsonFormat { + /** + * @generated from enum value: JSON_FORMAT_UNKNOWN = 0; + */ + JSON_FORMAT_UNKNOWN = 0, + /** + * @generated from enum value: ALLOW = 1; + */ + ALLOW = 1, + /** + * @generated from enum value: LEGACY_BEST_EFFORT = 2; + */ + LEGACY_BEST_EFFORT = 2 +} +/** + * @generated from enum google.protobuf.FeatureSet.JsonFormat + */ +export type FeatureSet_JsonFormatJson = "JSON_FORMAT_UNKNOWN" | "ALLOW" | "LEGACY_BEST_EFFORT"; +/** + * Describes the enum google.protobuf.FeatureSet.JsonFormat. + */ +export declare const FeatureSet_JsonFormatSchema: GenEnum; +/** + * @generated from enum google.protobuf.FeatureSet.EnforceNamingStyle + */ +export declare enum FeatureSet_EnforceNamingStyle { + /** + * @generated from enum value: ENFORCE_NAMING_STYLE_UNKNOWN = 0; + */ + ENFORCE_NAMING_STYLE_UNKNOWN = 0, + /** + * @generated from enum value: STYLE2024 = 1; + */ + STYLE2024 = 1, + /** + * @generated from enum value: STYLE_LEGACY = 2; + */ + STYLE_LEGACY = 2 +} +/** + * @generated from enum google.protobuf.FeatureSet.EnforceNamingStyle + */ +export type FeatureSet_EnforceNamingStyleJson = "ENFORCE_NAMING_STYLE_UNKNOWN" | "STYLE2024" | "STYLE_LEGACY"; +/** + * Describes the enum google.protobuf.FeatureSet.EnforceNamingStyle. + */ +export declare const FeatureSet_EnforceNamingStyleSchema: GenEnum; +/** + * A compiled specification for the defaults of a set of features. These + * messages are generated from FeatureSet extensions and can be used to seed + * feature resolution. The resolution with this object becomes a simple search + * for the closest matching edition, followed by proto merges. + * + * @generated from message google.protobuf.FeatureSetDefaults + */ +export type FeatureSetDefaults = Message<"google.protobuf.FeatureSetDefaults"> & { + /** + * @generated from field: repeated google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults = 1; + */ + defaults: FeatureSetDefaults_FeatureSetEditionDefault[]; + /** + * The minimum supported edition (inclusive) when this was constructed. + * Editions before this will not have defaults. + * + * @generated from field: optional google.protobuf.Edition minimum_edition = 4; + */ + minimumEdition: Edition; + /** + * The maximum known edition (inclusive) when this was constructed. Editions + * after this will not have reliable defaults. + * + * @generated from field: optional google.protobuf.Edition maximum_edition = 5; + */ + maximumEdition: Edition; +}; +/** + * A compiled specification for the defaults of a set of features. These + * messages are generated from FeatureSet extensions and can be used to seed + * feature resolution. The resolution with this object becomes a simple search + * for the closest matching edition, followed by proto merges. + * + * @generated from message google.protobuf.FeatureSetDefaults + */ +export type FeatureSetDefaultsJson = { + /** + * @generated from field: repeated google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults = 1; + */ + defaults?: FeatureSetDefaults_FeatureSetEditionDefaultJson[]; + /** + * The minimum supported edition (inclusive) when this was constructed. + * Editions before this will not have defaults. + * + * @generated from field: optional google.protobuf.Edition minimum_edition = 4; + */ + minimumEdition?: EditionJson; + /** + * The maximum known edition (inclusive) when this was constructed. Editions + * after this will not have reliable defaults. + * + * @generated from field: optional google.protobuf.Edition maximum_edition = 5; + */ + maximumEdition?: EditionJson; +}; +/** + * Describes the message google.protobuf.FeatureSetDefaults. + * Use `create(FeatureSetDefaultsSchema)` to create a new message. + */ +export declare const FeatureSetDefaultsSchema: GenMessage; +/** + * A map from every known edition with a unique set of defaults to its + * defaults. Not all editions may be contained here. For a given edition, + * the defaults at the closest matching edition ordered at or before it should + * be used. This field must be in strict ascending order by edition. + * + * @generated from message google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault + */ +export type FeatureSetDefaults_FeatureSetEditionDefault = Message<"google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault"> & { + /** + * @generated from field: optional google.protobuf.Edition edition = 3; + */ + edition: Edition; + /** + * Defaults of features that can be overridden in this edition. + * + * @generated from field: optional google.protobuf.FeatureSet overridable_features = 4; + */ + overridableFeatures?: FeatureSet; + /** + * Defaults of features that can't be overridden in this edition. + * + * @generated from field: optional google.protobuf.FeatureSet fixed_features = 5; + */ + fixedFeatures?: FeatureSet; +}; +/** + * A map from every known edition with a unique set of defaults to its + * defaults. Not all editions may be contained here. For a given edition, + * the defaults at the closest matching edition ordered at or before it should + * be used. This field must be in strict ascending order by edition. + * + * @generated from message google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault + */ +export type FeatureSetDefaults_FeatureSetEditionDefaultJson = { + /** + * @generated from field: optional google.protobuf.Edition edition = 3; + */ + edition?: EditionJson; + /** + * Defaults of features that can be overridden in this edition. + * + * @generated from field: optional google.protobuf.FeatureSet overridable_features = 4; + */ + overridableFeatures?: FeatureSetJson; + /** + * Defaults of features that can't be overridden in this edition. + * + * @generated from field: optional google.protobuf.FeatureSet fixed_features = 5; + */ + fixedFeatures?: FeatureSetJson; +}; +/** + * Describes the message google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault. + * Use `create(FeatureSetDefaults_FeatureSetEditionDefaultSchema)` to create a new message. + */ +export declare const FeatureSetDefaults_FeatureSetEditionDefaultSchema: GenMessage; +/** + * Encapsulates information about the original source file from which a + * FileDescriptorProto was generated. + * + * @generated from message google.protobuf.SourceCodeInfo + */ +export type SourceCodeInfo = Message<"google.protobuf.SourceCodeInfo"> & { + /** + * A Location identifies a piece of source code in a .proto file which + * corresponds to a particular definition. This information is intended + * to be useful to IDEs, code indexers, documentation generators, and similar + * tools. + * + * For example, say we have a file like: + * message Foo { + * optional string foo = 1; + * } + * Let's look at just the field definition: + * optional string foo = 1; + * ^ ^^ ^^ ^ ^^^ + * a bc de f ghi + * We have the following locations: + * span path represents + * [a,i) [ 4, 0, 2, 0 ] The whole field definition. + * [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). + * [c,d) [ 4, 0, 2, 0, 5 ] The type (string). + * [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). + * [g,h) [ 4, 0, 2, 0, 3 ] The number (1). + * + * Notes: + * - A location may refer to a repeated field itself (i.e. not to any + * particular index within it). This is used whenever a set of elements are + * logically enclosed in a single code segment. For example, an entire + * extend block (possibly containing multiple extension definitions) will + * have an outer location whose path refers to the "extensions" repeated + * field without an index. + * - Multiple locations may have the same path. This happens when a single + * logical declaration is spread out across multiple places. The most + * obvious example is the "extend" block again -- there may be multiple + * extend blocks in the same scope, each of which will have the same path. + * - A location's span is not always a subset of its parent's span. For + * example, the "extendee" of an extension declaration appears at the + * beginning of the "extend" block and is shared by all extensions within + * the block. + * - Just because a location's span is a subset of some other location's span + * does not mean that it is a descendant. For example, a "group" defines + * both a type and a field in a single declaration. Thus, the locations + * corresponding to the type and field and their components will overlap. + * - Code which tries to interpret locations should probably be designed to + * ignore those that it doesn't understand, as more types of locations could + * be recorded in the future. + * + * @generated from field: repeated google.protobuf.SourceCodeInfo.Location location = 1; + */ + location: SourceCodeInfo_Location[]; +}; +/** + * Encapsulates information about the original source file from which a + * FileDescriptorProto was generated. + * + * @generated from message google.protobuf.SourceCodeInfo + */ +export type SourceCodeInfoJson = { + /** + * A Location identifies a piece of source code in a .proto file which + * corresponds to a particular definition. This information is intended + * to be useful to IDEs, code indexers, documentation generators, and similar + * tools. + * + * For example, say we have a file like: + * message Foo { + * optional string foo = 1; + * } + * Let's look at just the field definition: + * optional string foo = 1; + * ^ ^^ ^^ ^ ^^^ + * a bc de f ghi + * We have the following locations: + * span path represents + * [a,i) [ 4, 0, 2, 0 ] The whole field definition. + * [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). + * [c,d) [ 4, 0, 2, 0, 5 ] The type (string). + * [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). + * [g,h) [ 4, 0, 2, 0, 3 ] The number (1). + * + * Notes: + * - A location may refer to a repeated field itself (i.e. not to any + * particular index within it). This is used whenever a set of elements are + * logically enclosed in a single code segment. For example, an entire + * extend block (possibly containing multiple extension definitions) will + * have an outer location whose path refers to the "extensions" repeated + * field without an index. + * - Multiple locations may have the same path. This happens when a single + * logical declaration is spread out across multiple places. The most + * obvious example is the "extend" block again -- there may be multiple + * extend blocks in the same scope, each of which will have the same path. + * - A location's span is not always a subset of its parent's span. For + * example, the "extendee" of an extension declaration appears at the + * beginning of the "extend" block and is shared by all extensions within + * the block. + * - Just because a location's span is a subset of some other location's span + * does not mean that it is a descendant. For example, a "group" defines + * both a type and a field in a single declaration. Thus, the locations + * corresponding to the type and field and their components will overlap. + * - Code which tries to interpret locations should probably be designed to + * ignore those that it doesn't understand, as more types of locations could + * be recorded in the future. + * + * @generated from field: repeated google.protobuf.SourceCodeInfo.Location location = 1; + */ + location?: SourceCodeInfo_LocationJson[]; +}; +/** + * Describes the message google.protobuf.SourceCodeInfo. + * Use `create(SourceCodeInfoSchema)` to create a new message. + */ +export declare const SourceCodeInfoSchema: GenMessage; +/** + * @generated from message google.protobuf.SourceCodeInfo.Location + */ +export type SourceCodeInfo_Location = Message<"google.protobuf.SourceCodeInfo.Location"> & { + /** + * Identifies which part of the FileDescriptorProto was defined at this + * location. + * + * Each element is a field number or an index. They form a path from + * the root FileDescriptorProto to the place where the definition appears. + * For example, this path: + * [ 4, 3, 2, 7, 1 ] + * refers to: + * file.message_type(3) // 4, 3 + * .field(7) // 2, 7 + * .name() // 1 + * This is because FileDescriptorProto.message_type has field number 4: + * repeated DescriptorProto message_type = 4; + * and DescriptorProto.field has field number 2: + * repeated FieldDescriptorProto field = 2; + * and FieldDescriptorProto.name has field number 1: + * optional string name = 1; + * + * Thus, the above path gives the location of a field name. If we removed + * the last element: + * [ 4, 3, 2, 7 ] + * this path refers to the whole field declaration (from the beginning + * of the label to the terminating semicolon). + * + * @generated from field: repeated int32 path = 1 [packed = true]; + */ + path: number[]; + /** + * Always has exactly three or four elements: start line, start column, + * end line (optional, otherwise assumed same as start line), end column. + * These are packed into a single field for efficiency. Note that line + * and column numbers are zero-based -- typically you will want to add + * 1 to each before displaying to a user. + * + * @generated from field: repeated int32 span = 2 [packed = true]; + */ + span: number[]; + /** + * If this SourceCodeInfo represents a complete declaration, these are any + * comments appearing before and after the declaration which appear to be + * attached to the declaration. + * + * A series of line comments appearing on consecutive lines, with no other + * tokens appearing on those lines, will be treated as a single comment. + * + * leading_detached_comments will keep paragraphs of comments that appear + * before (but not connected to) the current element. Each paragraph, + * separated by empty lines, will be one comment element in the repeated + * field. + * + * Only the comment content is provided; comment markers (e.g. //) are + * stripped out. For block comments, leading whitespace and an asterisk + * will be stripped from the beginning of each line other than the first. + * Newlines are included in the output. + * + * Examples: + * + * optional int32 foo = 1; // Comment attached to foo. + * // Comment attached to bar. + * optional int32 bar = 2; + * + * optional string baz = 3; + * // Comment attached to baz. + * // Another line attached to baz. + * + * // Comment attached to moo. + * // + * // Another line attached to moo. + * optional double moo = 4; + * + * // Detached comment for corge. This is not leading or trailing comments + * // to moo or corge because there are blank lines separating it from + * // both. + * + * // Detached comment for corge paragraph 2. + * + * optional string corge = 5; + * /* Block comment attached + * * to corge. Leading asterisks + * * will be removed. *\/ + * /* Block comment attached to + * * grault. *\/ + * optional int32 grault = 6; + * + * // ignored detached comments. + * + * @generated from field: optional string leading_comments = 3; + */ + leadingComments: string; + /** + * @generated from field: optional string trailing_comments = 4; + */ + trailingComments: string; + /** + * @generated from field: repeated string leading_detached_comments = 6; + */ + leadingDetachedComments: string[]; +}; +/** + * @generated from message google.protobuf.SourceCodeInfo.Location + */ +export type SourceCodeInfo_LocationJson = { + /** + * Identifies which part of the FileDescriptorProto was defined at this + * location. + * + * Each element is a field number or an index. They form a path from + * the root FileDescriptorProto to the place where the definition appears. + * For example, this path: + * [ 4, 3, 2, 7, 1 ] + * refers to: + * file.message_type(3) // 4, 3 + * .field(7) // 2, 7 + * .name() // 1 + * This is because FileDescriptorProto.message_type has field number 4: + * repeated DescriptorProto message_type = 4; + * and DescriptorProto.field has field number 2: + * repeated FieldDescriptorProto field = 2; + * and FieldDescriptorProto.name has field number 1: + * optional string name = 1; + * + * Thus, the above path gives the location of a field name. If we removed + * the last element: + * [ 4, 3, 2, 7 ] + * this path refers to the whole field declaration (from the beginning + * of the label to the terminating semicolon). + * + * @generated from field: repeated int32 path = 1 [packed = true]; + */ + path?: number[]; + /** + * Always has exactly three or four elements: start line, start column, + * end line (optional, otherwise assumed same as start line), end column. + * These are packed into a single field for efficiency. Note that line + * and column numbers are zero-based -- typically you will want to add + * 1 to each before displaying to a user. + * + * @generated from field: repeated int32 span = 2 [packed = true]; + */ + span?: number[]; + /** + * If this SourceCodeInfo represents a complete declaration, these are any + * comments appearing before and after the declaration which appear to be + * attached to the declaration. + * + * A series of line comments appearing on consecutive lines, with no other + * tokens appearing on those lines, will be treated as a single comment. + * + * leading_detached_comments will keep paragraphs of comments that appear + * before (but not connected to) the current element. Each paragraph, + * separated by empty lines, will be one comment element in the repeated + * field. + * + * Only the comment content is provided; comment markers (e.g. //) are + * stripped out. For block comments, leading whitespace and an asterisk + * will be stripped from the beginning of each line other than the first. + * Newlines are included in the output. + * + * Examples: + * + * optional int32 foo = 1; // Comment attached to foo. + * // Comment attached to bar. + * optional int32 bar = 2; + * + * optional string baz = 3; + * // Comment attached to baz. + * // Another line attached to baz. + * + * // Comment attached to moo. + * // + * // Another line attached to moo. + * optional double moo = 4; + * + * // Detached comment for corge. This is not leading or trailing comments + * // to moo or corge because there are blank lines separating it from + * // both. + * + * // Detached comment for corge paragraph 2. + * + * optional string corge = 5; + * /* Block comment attached + * * to corge. Leading asterisks + * * will be removed. *\/ + * /* Block comment attached to + * * grault. *\/ + * optional int32 grault = 6; + * + * // ignored detached comments. + * + * @generated from field: optional string leading_comments = 3; + */ + leadingComments?: string; + /** + * @generated from field: optional string trailing_comments = 4; + */ + trailingComments?: string; + /** + * @generated from field: repeated string leading_detached_comments = 6; + */ + leadingDetachedComments?: string[]; +}; +/** + * Describes the message google.protobuf.SourceCodeInfo.Location. + * Use `create(SourceCodeInfo_LocationSchema)` to create a new message. + */ +export declare const SourceCodeInfo_LocationSchema: GenMessage; +/** + * Describes the relationship between generated code and its original source + * file. A GeneratedCodeInfo message is associated with only one generated + * source file, but may contain references to different source .proto files. + * + * @generated from message google.protobuf.GeneratedCodeInfo + */ +export type GeneratedCodeInfo = Message<"google.protobuf.GeneratedCodeInfo"> & { + /** + * An Annotation connects some span of text in generated code to an element + * of its generating .proto file. + * + * @generated from field: repeated google.protobuf.GeneratedCodeInfo.Annotation annotation = 1; + */ + annotation: GeneratedCodeInfo_Annotation[]; +}; +/** + * Describes the relationship between generated code and its original source + * file. A GeneratedCodeInfo message is associated with only one generated + * source file, but may contain references to different source .proto files. + * + * @generated from message google.protobuf.GeneratedCodeInfo + */ +export type GeneratedCodeInfoJson = { + /** + * An Annotation connects some span of text in generated code to an element + * of its generating .proto file. + * + * @generated from field: repeated google.protobuf.GeneratedCodeInfo.Annotation annotation = 1; + */ + annotation?: GeneratedCodeInfo_AnnotationJson[]; +}; +/** + * Describes the message google.protobuf.GeneratedCodeInfo. + * Use `create(GeneratedCodeInfoSchema)` to create a new message. + */ +export declare const GeneratedCodeInfoSchema: GenMessage; +/** + * @generated from message google.protobuf.GeneratedCodeInfo.Annotation + */ +export type GeneratedCodeInfo_Annotation = Message<"google.protobuf.GeneratedCodeInfo.Annotation"> & { + /** + * Identifies the element in the original source .proto file. This field + * is formatted the same as SourceCodeInfo.Location.path. + * + * @generated from field: repeated int32 path = 1 [packed = true]; + */ + path: number[]; + /** + * Identifies the filesystem path to the original source .proto. + * + * @generated from field: optional string source_file = 2; + */ + sourceFile: string; + /** + * Identifies the starting offset in bytes in the generated code + * that relates to the identified object. + * + * @generated from field: optional int32 begin = 3; + */ + begin: number; + /** + * Identifies the ending offset in bytes in the generated code that + * relates to the identified object. The end offset should be one past + * the last relevant byte (so the length of the text = end - begin). + * + * @generated from field: optional int32 end = 4; + */ + end: number; + /** + * @generated from field: optional google.protobuf.GeneratedCodeInfo.Annotation.Semantic semantic = 5; + */ + semantic: GeneratedCodeInfo_Annotation_Semantic; +}; +/** + * @generated from message google.protobuf.GeneratedCodeInfo.Annotation + */ +export type GeneratedCodeInfo_AnnotationJson = { + /** + * Identifies the element in the original source .proto file. This field + * is formatted the same as SourceCodeInfo.Location.path. + * + * @generated from field: repeated int32 path = 1 [packed = true]; + */ + path?: number[]; + /** + * Identifies the filesystem path to the original source .proto. + * + * @generated from field: optional string source_file = 2; + */ + sourceFile?: string; + /** + * Identifies the starting offset in bytes in the generated code + * that relates to the identified object. + * + * @generated from field: optional int32 begin = 3; + */ + begin?: number; + /** + * Identifies the ending offset in bytes in the generated code that + * relates to the identified object. The end offset should be one past + * the last relevant byte (so the length of the text = end - begin). + * + * @generated from field: optional int32 end = 4; + */ + end?: number; + /** + * @generated from field: optional google.protobuf.GeneratedCodeInfo.Annotation.Semantic semantic = 5; + */ + semantic?: GeneratedCodeInfo_Annotation_SemanticJson; +}; +/** + * Describes the message google.protobuf.GeneratedCodeInfo.Annotation. + * Use `create(GeneratedCodeInfo_AnnotationSchema)` to create a new message. + */ +export declare const GeneratedCodeInfo_AnnotationSchema: GenMessage; +/** + * Represents the identified object's effect on the element in the original + * .proto file. + * + * @generated from enum google.protobuf.GeneratedCodeInfo.Annotation.Semantic + */ +export declare enum GeneratedCodeInfo_Annotation_Semantic { + /** + * There is no effect or the effect is indescribable. + * + * @generated from enum value: NONE = 0; + */ + NONE = 0, + /** + * The element is set or otherwise mutated. + * + * @generated from enum value: SET = 1; + */ + SET = 1, + /** + * An alias to the element is returned. + * + * @generated from enum value: ALIAS = 2; + */ + ALIAS = 2 +} +/** + * Represents the identified object's effect on the element in the original + * .proto file. + * + * @generated from enum google.protobuf.GeneratedCodeInfo.Annotation.Semantic + */ +export type GeneratedCodeInfo_Annotation_SemanticJson = "NONE" | "SET" | "ALIAS"; +/** + * Describes the enum google.protobuf.GeneratedCodeInfo.Annotation.Semantic. + */ +export declare const GeneratedCodeInfo_Annotation_SemanticSchema: GenEnum; +/** + * The full set of known editions. + * + * @generated from enum google.protobuf.Edition + */ +export declare enum Edition { + /** + * A placeholder for an unknown edition value. + * + * @generated from enum value: EDITION_UNKNOWN = 0; + */ + EDITION_UNKNOWN = 0, + /** + * A placeholder edition for specifying default behaviors *before* a feature + * was first introduced. This is effectively an "infinite past". + * + * @generated from enum value: EDITION_LEGACY = 900; + */ + EDITION_LEGACY = 900, + /** + * Legacy syntax "editions". These pre-date editions, but behave much like + * distinct editions. These can't be used to specify the edition of proto + * files, but feature definitions must supply proto2/proto3 defaults for + * backwards compatibility. + * + * @generated from enum value: EDITION_PROTO2 = 998; + */ + EDITION_PROTO2 = 998, + /** + * @generated from enum value: EDITION_PROTO3 = 999; + */ + EDITION_PROTO3 = 999, + /** + * Editions that have been released. The specific values are arbitrary and + * should not be depended on, but they will always be time-ordered for easy + * comparison. + * + * @generated from enum value: EDITION_2023 = 1000; + */ + EDITION_2023 = 1000, + /** + * @generated from enum value: EDITION_2024 = 1001; + */ + EDITION_2024 = 1001, + /** + * Placeholder editions for testing feature resolution. These should not be + * used or relied on outside of tests. + * + * @generated from enum value: EDITION_1_TEST_ONLY = 1; + */ + EDITION_1_TEST_ONLY = 1, + /** + * @generated from enum value: EDITION_2_TEST_ONLY = 2; + */ + EDITION_2_TEST_ONLY = 2, + /** + * @generated from enum value: EDITION_99997_TEST_ONLY = 99997; + */ + EDITION_99997_TEST_ONLY = 99997, + /** + * @generated from enum value: EDITION_99998_TEST_ONLY = 99998; + */ + EDITION_99998_TEST_ONLY = 99998, + /** + * @generated from enum value: EDITION_99999_TEST_ONLY = 99999; + */ + EDITION_99999_TEST_ONLY = 99999, + /** + * Placeholder for specifying unbounded edition support. This should only + * ever be used by plugins that can expect to never require any changes to + * support a new edition. + * + * @generated from enum value: EDITION_MAX = 2147483647; + */ + EDITION_MAX = 2147483647 +} +/** + * The full set of known editions. + * + * @generated from enum google.protobuf.Edition + */ +export type EditionJson = "EDITION_UNKNOWN" | "EDITION_LEGACY" | "EDITION_PROTO2" | "EDITION_PROTO3" | "EDITION_2023" | "EDITION_2024" | "EDITION_1_TEST_ONLY" | "EDITION_2_TEST_ONLY" | "EDITION_99997_TEST_ONLY" | "EDITION_99998_TEST_ONLY" | "EDITION_99999_TEST_ONLY" | "EDITION_MAX"; +/** + * Describes the enum google.protobuf.Edition. + */ +export declare const EditionSchema: GenEnum; +/** + * Describes the 'visibility' of a symbol with respect to the proto import + * system. Symbols can only be imported when the visibility rules do not prevent + * it (ex: local symbols cannot be imported). Visibility modifiers can only set + * on `message` and `enum` as they are the only types available to be referenced + * from other files. + * + * @generated from enum google.protobuf.SymbolVisibility + */ +export declare enum SymbolVisibility { + /** + * @generated from enum value: VISIBILITY_UNSET = 0; + */ + VISIBILITY_UNSET = 0, + /** + * @generated from enum value: VISIBILITY_LOCAL = 1; + */ + VISIBILITY_LOCAL = 1, + /** + * @generated from enum value: VISIBILITY_EXPORT = 2; + */ + VISIBILITY_EXPORT = 2 +} +/** + * Describes the 'visibility' of a symbol with respect to the proto import + * system. Symbols can only be imported when the visibility rules do not prevent + * it (ex: local symbols cannot be imported). Visibility modifiers can only set + * on `message` and `enum` as they are the only types available to be referenced + * from other files. + * + * @generated from enum google.protobuf.SymbolVisibility + */ +export type SymbolVisibilityJson = "VISIBILITY_UNSET" | "VISIBILITY_LOCAL" | "VISIBILITY_EXPORT"; +/** + * Describes the enum google.protobuf.SymbolVisibility. + */ +export declare const SymbolVisibilitySchema: GenEnum; diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/descriptor_pb.js b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/descriptor_pb.js new file mode 100644 index 0000000000000000000000000000000000000000..70c8c24ab4707f6a11716b4d6a2a17ff92cfac06 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/descriptor_pb.js @@ -0,0 +1,882 @@ +// Copyright 2021-2025 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. +import { boot } from "../../../../codegenv2/boot.js"; +import { messageDesc } from "../../../../codegenv2/message.js"; +import { enumDesc } from "../../../../codegenv2/enum.js"; +/** + * Describes the file google/protobuf/descriptor.proto. + */ +export const file_google_protobuf_descriptor = /*@__PURE__*/ boot({ "name": "google/protobuf/descriptor.proto", "package": "google.protobuf", "messageType": [{ "name": "FileDescriptorSet", "field": [{ "name": "file", "number": 1, "type": 11, "label": 3, "typeName": ".google.protobuf.FileDescriptorProto" }], "extensionRange": [{ "start": 536000000, "end": 536000001 }] }, { "name": "FileDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "package", "number": 2, "type": 9, "label": 1 }, { "name": "dependency", "number": 3, "type": 9, "label": 3 }, { "name": "public_dependency", "number": 10, "type": 5, "label": 3 }, { "name": "weak_dependency", "number": 11, "type": 5, "label": 3 }, { "name": "option_dependency", "number": 15, "type": 9, "label": 3 }, { "name": "message_type", "number": 4, "type": 11, "label": 3, "typeName": ".google.protobuf.DescriptorProto" }, { "name": "enum_type", "number": 5, "type": 11, "label": 3, "typeName": ".google.protobuf.EnumDescriptorProto" }, { "name": "service", "number": 6, "type": 11, "label": 3, "typeName": ".google.protobuf.ServiceDescriptorProto" }, { "name": "extension", "number": 7, "type": 11, "label": 3, "typeName": ".google.protobuf.FieldDescriptorProto" }, { "name": "options", "number": 8, "type": 11, "label": 1, "typeName": ".google.protobuf.FileOptions" }, { "name": "source_code_info", "number": 9, "type": 11, "label": 1, "typeName": ".google.protobuf.SourceCodeInfo" }, { "name": "syntax", "number": 12, "type": 9, "label": 1 }, { "name": "edition", "number": 14, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }] }, { "name": "DescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "field", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.FieldDescriptorProto" }, { "name": "extension", "number": 6, "type": 11, "label": 3, "typeName": ".google.protobuf.FieldDescriptorProto" }, { "name": "nested_type", "number": 3, "type": 11, "label": 3, "typeName": ".google.protobuf.DescriptorProto" }, { "name": "enum_type", "number": 4, "type": 11, "label": 3, "typeName": ".google.protobuf.EnumDescriptorProto" }, { "name": "extension_range", "number": 5, "type": 11, "label": 3, "typeName": ".google.protobuf.DescriptorProto.ExtensionRange" }, { "name": "oneof_decl", "number": 8, "type": 11, "label": 3, "typeName": ".google.protobuf.OneofDescriptorProto" }, { "name": "options", "number": 7, "type": 11, "label": 1, "typeName": ".google.protobuf.MessageOptions" }, { "name": "reserved_range", "number": 9, "type": 11, "label": 3, "typeName": ".google.protobuf.DescriptorProto.ReservedRange" }, { "name": "reserved_name", "number": 10, "type": 9, "label": 3 }, { "name": "visibility", "number": 11, "type": 14, "label": 1, "typeName": ".google.protobuf.SymbolVisibility" }], "nestedType": [{ "name": "ExtensionRange", "field": [{ "name": "start", "number": 1, "type": 5, "label": 1 }, { "name": "end", "number": 2, "type": 5, "label": 1 }, { "name": "options", "number": 3, "type": 11, "label": 1, "typeName": ".google.protobuf.ExtensionRangeOptions" }] }, { "name": "ReservedRange", "field": [{ "name": "start", "number": 1, "type": 5, "label": 1 }, { "name": "end", "number": 2, "type": 5, "label": 1 }] }] }, { "name": "ExtensionRangeOptions", "field": [{ "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }, { "name": "declaration", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.ExtensionRangeOptions.Declaration", "options": { "retention": 2 } }, { "name": "features", "number": 50, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "verification", "number": 3, "type": 14, "label": 1, "typeName": ".google.protobuf.ExtensionRangeOptions.VerificationState", "defaultValue": "UNVERIFIED", "options": { "retention": 2 } }], "nestedType": [{ "name": "Declaration", "field": [{ "name": "number", "number": 1, "type": 5, "label": 1 }, { "name": "full_name", "number": 2, "type": 9, "label": 1 }, { "name": "type", "number": 3, "type": 9, "label": 1 }, { "name": "reserved", "number": 5, "type": 8, "label": 1 }, { "name": "repeated", "number": 6, "type": 8, "label": 1 }] }], "enumType": [{ "name": "VerificationState", "value": [{ "name": "DECLARATION", "number": 0 }, { "name": "UNVERIFIED", "number": 1 }] }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "FieldDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "number", "number": 3, "type": 5, "label": 1 }, { "name": "label", "number": 4, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldDescriptorProto.Label" }, { "name": "type", "number": 5, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldDescriptorProto.Type" }, { "name": "type_name", "number": 6, "type": 9, "label": 1 }, { "name": "extendee", "number": 2, "type": 9, "label": 1 }, { "name": "default_value", "number": 7, "type": 9, "label": 1 }, { "name": "oneof_index", "number": 9, "type": 5, "label": 1 }, { "name": "json_name", "number": 10, "type": 9, "label": 1 }, { "name": "options", "number": 8, "type": 11, "label": 1, "typeName": ".google.protobuf.FieldOptions" }, { "name": "proto3_optional", "number": 17, "type": 8, "label": 1 }], "enumType": [{ "name": "Type", "value": [{ "name": "TYPE_DOUBLE", "number": 1 }, { "name": "TYPE_FLOAT", "number": 2 }, { "name": "TYPE_INT64", "number": 3 }, { "name": "TYPE_UINT64", "number": 4 }, { "name": "TYPE_INT32", "number": 5 }, { "name": "TYPE_FIXED64", "number": 6 }, { "name": "TYPE_FIXED32", "number": 7 }, { "name": "TYPE_BOOL", "number": 8 }, { "name": "TYPE_STRING", "number": 9 }, { "name": "TYPE_GROUP", "number": 10 }, { "name": "TYPE_MESSAGE", "number": 11 }, { "name": "TYPE_BYTES", "number": 12 }, { "name": "TYPE_UINT32", "number": 13 }, { "name": "TYPE_ENUM", "number": 14 }, { "name": "TYPE_SFIXED32", "number": 15 }, { "name": "TYPE_SFIXED64", "number": 16 }, { "name": "TYPE_SINT32", "number": 17 }, { "name": "TYPE_SINT64", "number": 18 }] }, { "name": "Label", "value": [{ "name": "LABEL_OPTIONAL", "number": 1 }, { "name": "LABEL_REPEATED", "number": 3 }, { "name": "LABEL_REQUIRED", "number": 2 }] }] }, { "name": "OneofDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "options", "number": 2, "type": 11, "label": 1, "typeName": ".google.protobuf.OneofOptions" }] }, { "name": "EnumDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "value", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.EnumValueDescriptorProto" }, { "name": "options", "number": 3, "type": 11, "label": 1, "typeName": ".google.protobuf.EnumOptions" }, { "name": "reserved_range", "number": 4, "type": 11, "label": 3, "typeName": ".google.protobuf.EnumDescriptorProto.EnumReservedRange" }, { "name": "reserved_name", "number": 5, "type": 9, "label": 3 }, { "name": "visibility", "number": 6, "type": 14, "label": 1, "typeName": ".google.protobuf.SymbolVisibility" }], "nestedType": [{ "name": "EnumReservedRange", "field": [{ "name": "start", "number": 1, "type": 5, "label": 1 }, { "name": "end", "number": 2, "type": 5, "label": 1 }] }] }, { "name": "EnumValueDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "number", "number": 2, "type": 5, "label": 1 }, { "name": "options", "number": 3, "type": 11, "label": 1, "typeName": ".google.protobuf.EnumValueOptions" }] }, { "name": "ServiceDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "method", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.MethodDescriptorProto" }, { "name": "options", "number": 3, "type": 11, "label": 1, "typeName": ".google.protobuf.ServiceOptions" }] }, { "name": "MethodDescriptorProto", "field": [{ "name": "name", "number": 1, "type": 9, "label": 1 }, { "name": "input_type", "number": 2, "type": 9, "label": 1 }, { "name": "output_type", "number": 3, "type": 9, "label": 1 }, { "name": "options", "number": 4, "type": 11, "label": 1, "typeName": ".google.protobuf.MethodOptions" }, { "name": "client_streaming", "number": 5, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "server_streaming", "number": 6, "type": 8, "label": 1, "defaultValue": "false" }] }, { "name": "FileOptions", "field": [{ "name": "java_package", "number": 1, "type": 9, "label": 1 }, { "name": "java_outer_classname", "number": 8, "type": 9, "label": 1 }, { "name": "java_multiple_files", "number": 10, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "java_generate_equals_and_hash", "number": 20, "type": 8, "label": 1, "options": { "deprecated": true } }, { "name": "java_string_check_utf8", "number": 27, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "optimize_for", "number": 9, "type": 14, "label": 1, "typeName": ".google.protobuf.FileOptions.OptimizeMode", "defaultValue": "SPEED" }, { "name": "go_package", "number": 11, "type": 9, "label": 1 }, { "name": "cc_generic_services", "number": 16, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "java_generic_services", "number": 17, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "py_generic_services", "number": 18, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "deprecated", "number": 23, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "cc_enable_arenas", "number": 31, "type": 8, "label": 1, "defaultValue": "true" }, { "name": "objc_class_prefix", "number": 36, "type": 9, "label": 1 }, { "name": "csharp_namespace", "number": 37, "type": 9, "label": 1 }, { "name": "swift_prefix", "number": 39, "type": 9, "label": 1 }, { "name": "php_class_prefix", "number": 40, "type": 9, "label": 1 }, { "name": "php_namespace", "number": 41, "type": 9, "label": 1 }, { "name": "php_metadata_namespace", "number": 44, "type": 9, "label": 1 }, { "name": "ruby_package", "number": 45, "type": 9, "label": 1 }, { "name": "features", "number": 50, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "enumType": [{ "name": "OptimizeMode", "value": [{ "name": "SPEED", "number": 1 }, { "name": "CODE_SIZE", "number": 2 }, { "name": "LITE_RUNTIME", "number": 3 }] }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "MessageOptions", "field": [{ "name": "message_set_wire_format", "number": 1, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "no_standard_descriptor_accessor", "number": 2, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "deprecated", "number": 3, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "map_entry", "number": 7, "type": 8, "label": 1 }, { "name": "deprecated_legacy_json_field_conflicts", "number": 11, "type": 8, "label": 1, "options": { "deprecated": true } }, { "name": "features", "number": 12, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "FieldOptions", "field": [{ "name": "ctype", "number": 1, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldOptions.CType", "defaultValue": "STRING" }, { "name": "packed", "number": 2, "type": 8, "label": 1 }, { "name": "jstype", "number": 6, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldOptions.JSType", "defaultValue": "JS_NORMAL" }, { "name": "lazy", "number": 5, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "unverified_lazy", "number": 15, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "deprecated", "number": 3, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "weak", "number": 10, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "debug_redact", "number": 16, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "retention", "number": 17, "type": 14, "label": 1, "typeName": ".google.protobuf.FieldOptions.OptionRetention" }, { "name": "targets", "number": 19, "type": 14, "label": 3, "typeName": ".google.protobuf.FieldOptions.OptionTargetType" }, { "name": "edition_defaults", "number": 20, "type": 11, "label": 3, "typeName": ".google.protobuf.FieldOptions.EditionDefault" }, { "name": "features", "number": 21, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "feature_support", "number": 22, "type": 11, "label": 1, "typeName": ".google.protobuf.FieldOptions.FeatureSupport" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "nestedType": [{ "name": "EditionDefault", "field": [{ "name": "edition", "number": 3, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "value", "number": 2, "type": 9, "label": 1 }] }, { "name": "FeatureSupport", "field": [{ "name": "edition_introduced", "number": 1, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "edition_deprecated", "number": 2, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "deprecation_warning", "number": 3, "type": 9, "label": 1 }, { "name": "edition_removed", "number": 4, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }] }], "enumType": [{ "name": "CType", "value": [{ "name": "STRING", "number": 0 }, { "name": "CORD", "number": 1 }, { "name": "STRING_PIECE", "number": 2 }] }, { "name": "JSType", "value": [{ "name": "JS_NORMAL", "number": 0 }, { "name": "JS_STRING", "number": 1 }, { "name": "JS_NUMBER", "number": 2 }] }, { "name": "OptionRetention", "value": [{ "name": "RETENTION_UNKNOWN", "number": 0 }, { "name": "RETENTION_RUNTIME", "number": 1 }, { "name": "RETENTION_SOURCE", "number": 2 }] }, { "name": "OptionTargetType", "value": [{ "name": "TARGET_TYPE_UNKNOWN", "number": 0 }, { "name": "TARGET_TYPE_FILE", "number": 1 }, { "name": "TARGET_TYPE_EXTENSION_RANGE", "number": 2 }, { "name": "TARGET_TYPE_MESSAGE", "number": 3 }, { "name": "TARGET_TYPE_FIELD", "number": 4 }, { "name": "TARGET_TYPE_ONEOF", "number": 5 }, { "name": "TARGET_TYPE_ENUM", "number": 6 }, { "name": "TARGET_TYPE_ENUM_ENTRY", "number": 7 }, { "name": "TARGET_TYPE_SERVICE", "number": 8 }, { "name": "TARGET_TYPE_METHOD", "number": 9 }] }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "OneofOptions", "field": [{ "name": "features", "number": 1, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "EnumOptions", "field": [{ "name": "allow_alias", "number": 2, "type": 8, "label": 1 }, { "name": "deprecated", "number": 3, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "deprecated_legacy_json_field_conflicts", "number": 6, "type": 8, "label": 1, "options": { "deprecated": true } }, { "name": "features", "number": 7, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "EnumValueOptions", "field": [{ "name": "deprecated", "number": 1, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "features", "number": 2, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "debug_redact", "number": 3, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "feature_support", "number": 4, "type": 11, "label": 1, "typeName": ".google.protobuf.FieldOptions.FeatureSupport" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "ServiceOptions", "field": [{ "name": "features", "number": 34, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "deprecated", "number": 33, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "MethodOptions", "field": [{ "name": "deprecated", "number": 33, "type": 8, "label": 1, "defaultValue": "false" }, { "name": "idempotency_level", "number": 34, "type": 14, "label": 1, "typeName": ".google.protobuf.MethodOptions.IdempotencyLevel", "defaultValue": "IDEMPOTENCY_UNKNOWN" }, { "name": "features", "number": 35, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "uninterpreted_option", "number": 999, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption" }], "enumType": [{ "name": "IdempotencyLevel", "value": [{ "name": "IDEMPOTENCY_UNKNOWN", "number": 0 }, { "name": "NO_SIDE_EFFECTS", "number": 1 }, { "name": "IDEMPOTENT", "number": 2 }] }], "extensionRange": [{ "start": 1000, "end": 536870912 }] }, { "name": "UninterpretedOption", "field": [{ "name": "name", "number": 2, "type": 11, "label": 3, "typeName": ".google.protobuf.UninterpretedOption.NamePart" }, { "name": "identifier_value", "number": 3, "type": 9, "label": 1 }, { "name": "positive_int_value", "number": 4, "type": 4, "label": 1 }, { "name": "negative_int_value", "number": 5, "type": 3, "label": 1 }, { "name": "double_value", "number": 6, "type": 1, "label": 1 }, { "name": "string_value", "number": 7, "type": 12, "label": 1 }, { "name": "aggregate_value", "number": 8, "type": 9, "label": 1 }], "nestedType": [{ "name": "NamePart", "field": [{ "name": "name_part", "number": 1, "type": 9, "label": 2 }, { "name": "is_extension", "number": 2, "type": 8, "label": 2 }] }] }, { "name": "FeatureSet", "field": [{ "name": "field_presence", "number": 1, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.FieldPresence", "options": { "retention": 1, "targets": [4, 1], "editionDefaults": [{ "value": "EXPLICIT", "edition": 900 }, { "value": "IMPLICIT", "edition": 999 }, { "value": "EXPLICIT", "edition": 1000 }] } }, { "name": "enum_type", "number": 2, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.EnumType", "options": { "retention": 1, "targets": [6, 1], "editionDefaults": [{ "value": "CLOSED", "edition": 900 }, { "value": "OPEN", "edition": 999 }] } }, { "name": "repeated_field_encoding", "number": 3, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.RepeatedFieldEncoding", "options": { "retention": 1, "targets": [4, 1], "editionDefaults": [{ "value": "EXPANDED", "edition": 900 }, { "value": "PACKED", "edition": 999 }] } }, { "name": "utf8_validation", "number": 4, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.Utf8Validation", "options": { "retention": 1, "targets": [4, 1], "editionDefaults": [{ "value": "NONE", "edition": 900 }, { "value": "VERIFY", "edition": 999 }] } }, { "name": "message_encoding", "number": 5, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.MessageEncoding", "options": { "retention": 1, "targets": [4, 1], "editionDefaults": [{ "value": "LENGTH_PREFIXED", "edition": 900 }] } }, { "name": "json_format", "number": 6, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.JsonFormat", "options": { "retention": 1, "targets": [3, 6, 1], "editionDefaults": [{ "value": "LEGACY_BEST_EFFORT", "edition": 900 }, { "value": "ALLOW", "edition": 999 }] } }, { "name": "enforce_naming_style", "number": 7, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.EnforceNamingStyle", "options": { "retention": 2, "targets": [1, 2, 3, 4, 5, 6, 7, 8, 9], "editionDefaults": [{ "value": "STYLE_LEGACY", "edition": 900 }, { "value": "STYLE2024", "edition": 1001 }] } }, { "name": "default_symbol_visibility", "number": 8, "type": 14, "label": 1, "typeName": ".google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility", "options": { "retention": 2, "targets": [1], "editionDefaults": [{ "value": "EXPORT_ALL", "edition": 900 }, { "value": "EXPORT_TOP_LEVEL", "edition": 1001 }] } }], "nestedType": [{ "name": "VisibilityFeature", "enumType": [{ "name": "DefaultSymbolVisibility", "value": [{ "name": "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN", "number": 0 }, { "name": "EXPORT_ALL", "number": 1 }, { "name": "EXPORT_TOP_LEVEL", "number": 2 }, { "name": "LOCAL_ALL", "number": 3 }, { "name": "STRICT", "number": 4 }] }] }], "enumType": [{ "name": "FieldPresence", "value": [{ "name": "FIELD_PRESENCE_UNKNOWN", "number": 0 }, { "name": "EXPLICIT", "number": 1 }, { "name": "IMPLICIT", "number": 2 }, { "name": "LEGACY_REQUIRED", "number": 3 }] }, { "name": "EnumType", "value": [{ "name": "ENUM_TYPE_UNKNOWN", "number": 0 }, { "name": "OPEN", "number": 1 }, { "name": "CLOSED", "number": 2 }] }, { "name": "RepeatedFieldEncoding", "value": [{ "name": "REPEATED_FIELD_ENCODING_UNKNOWN", "number": 0 }, { "name": "PACKED", "number": 1 }, { "name": "EXPANDED", "number": 2 }] }, { "name": "Utf8Validation", "value": [{ "name": "UTF8_VALIDATION_UNKNOWN", "number": 0 }, { "name": "VERIFY", "number": 2 }, { "name": "NONE", "number": 3 }] }, { "name": "MessageEncoding", "value": [{ "name": "MESSAGE_ENCODING_UNKNOWN", "number": 0 }, { "name": "LENGTH_PREFIXED", "number": 1 }, { "name": "DELIMITED", "number": 2 }] }, { "name": "JsonFormat", "value": [{ "name": "JSON_FORMAT_UNKNOWN", "number": 0 }, { "name": "ALLOW", "number": 1 }, { "name": "LEGACY_BEST_EFFORT", "number": 2 }] }, { "name": "EnforceNamingStyle", "value": [{ "name": "ENFORCE_NAMING_STYLE_UNKNOWN", "number": 0 }, { "name": "STYLE2024", "number": 1 }, { "name": "STYLE_LEGACY", "number": 2 }] }], "extensionRange": [{ "start": 1000, "end": 9995 }, { "start": 9995, "end": 10000 }, { "start": 10000, "end": 10001 }] }, { "name": "FeatureSetDefaults", "field": [{ "name": "defaults", "number": 1, "type": 11, "label": 3, "typeName": ".google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault" }, { "name": "minimum_edition", "number": 4, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "maximum_edition", "number": 5, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }], "nestedType": [{ "name": "FeatureSetEditionDefault", "field": [{ "name": "edition", "number": 3, "type": 14, "label": 1, "typeName": ".google.protobuf.Edition" }, { "name": "overridable_features", "number": 4, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }, { "name": "fixed_features", "number": 5, "type": 11, "label": 1, "typeName": ".google.protobuf.FeatureSet" }] }] }, { "name": "SourceCodeInfo", "field": [{ "name": "location", "number": 1, "type": 11, "label": 3, "typeName": ".google.protobuf.SourceCodeInfo.Location" }], "nestedType": [{ "name": "Location", "field": [{ "name": "path", "number": 1, "type": 5, "label": 3, "options": { "packed": true } }, { "name": "span", "number": 2, "type": 5, "label": 3, "options": { "packed": true } }, { "name": "leading_comments", "number": 3, "type": 9, "label": 1 }, { "name": "trailing_comments", "number": 4, "type": 9, "label": 1 }, { "name": "leading_detached_comments", "number": 6, "type": 9, "label": 3 }] }], "extensionRange": [{ "start": 536000000, "end": 536000001 }] }, { "name": "GeneratedCodeInfo", "field": [{ "name": "annotation", "number": 1, "type": 11, "label": 3, "typeName": ".google.protobuf.GeneratedCodeInfo.Annotation" }], "nestedType": [{ "name": "Annotation", "field": [{ "name": "path", "number": 1, "type": 5, "label": 3, "options": { "packed": true } }, { "name": "source_file", "number": 2, "type": 9, "label": 1 }, { "name": "begin", "number": 3, "type": 5, "label": 1 }, { "name": "end", "number": 4, "type": 5, "label": 1 }, { "name": "semantic", "number": 5, "type": 14, "label": 1, "typeName": ".google.protobuf.GeneratedCodeInfo.Annotation.Semantic" }], "enumType": [{ "name": "Semantic", "value": [{ "name": "NONE", "number": 0 }, { "name": "SET", "number": 1 }, { "name": "ALIAS", "number": 2 }] }] }] }], "enumType": [{ "name": "Edition", "value": [{ "name": "EDITION_UNKNOWN", "number": 0 }, { "name": "EDITION_LEGACY", "number": 900 }, { "name": "EDITION_PROTO2", "number": 998 }, { "name": "EDITION_PROTO3", "number": 999 }, { "name": "EDITION_2023", "number": 1000 }, { "name": "EDITION_2024", "number": 1001 }, { "name": "EDITION_1_TEST_ONLY", "number": 1 }, { "name": "EDITION_2_TEST_ONLY", "number": 2 }, { "name": "EDITION_99997_TEST_ONLY", "number": 99997 }, { "name": "EDITION_99998_TEST_ONLY", "number": 99998 }, { "name": "EDITION_99999_TEST_ONLY", "number": 99999 }, { "name": "EDITION_MAX", "number": 2147483647 }] }, { "name": "SymbolVisibility", "value": [{ "name": "VISIBILITY_UNSET", "number": 0 }, { "name": "VISIBILITY_LOCAL", "number": 1 }, { "name": "VISIBILITY_EXPORT", "number": 2 }] }] }); +/** + * Describes the message google.protobuf.FileDescriptorSet. + * Use `create(FileDescriptorSetSchema)` to create a new message. + */ +export const FileDescriptorSetSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 0); +/** + * Describes the message google.protobuf.FileDescriptorProto. + * Use `create(FileDescriptorProtoSchema)` to create a new message. + */ +export const FileDescriptorProtoSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 1); +/** + * Describes the message google.protobuf.DescriptorProto. + * Use `create(DescriptorProtoSchema)` to create a new message. + */ +export const DescriptorProtoSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 2); +/** + * Describes the message google.protobuf.DescriptorProto.ExtensionRange. + * Use `create(DescriptorProto_ExtensionRangeSchema)` to create a new message. + */ +export const DescriptorProto_ExtensionRangeSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 2, 0); +/** + * Describes the message google.protobuf.DescriptorProto.ReservedRange. + * Use `create(DescriptorProto_ReservedRangeSchema)` to create a new message. + */ +export const DescriptorProto_ReservedRangeSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 2, 1); +/** + * Describes the message google.protobuf.ExtensionRangeOptions. + * Use `create(ExtensionRangeOptionsSchema)` to create a new message. + */ +export const ExtensionRangeOptionsSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 3); +/** + * Describes the message google.protobuf.ExtensionRangeOptions.Declaration. + * Use `create(ExtensionRangeOptions_DeclarationSchema)` to create a new message. + */ +export const ExtensionRangeOptions_DeclarationSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 3, 0); +/** + * The verification state of the extension range. + * + * @generated from enum google.protobuf.ExtensionRangeOptions.VerificationState + */ +export var ExtensionRangeOptions_VerificationState; +(function (ExtensionRangeOptions_VerificationState) { + /** + * All the extensions of the range must be declared. + * + * @generated from enum value: DECLARATION = 0; + */ + ExtensionRangeOptions_VerificationState[ExtensionRangeOptions_VerificationState["DECLARATION"] = 0] = "DECLARATION"; + /** + * @generated from enum value: UNVERIFIED = 1; + */ + ExtensionRangeOptions_VerificationState[ExtensionRangeOptions_VerificationState["UNVERIFIED"] = 1] = "UNVERIFIED"; +})(ExtensionRangeOptions_VerificationState || (ExtensionRangeOptions_VerificationState = {})); +/** + * Describes the enum google.protobuf.ExtensionRangeOptions.VerificationState. + */ +export const ExtensionRangeOptions_VerificationStateSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 3, 0); +/** + * Describes the message google.protobuf.FieldDescriptorProto. + * Use `create(FieldDescriptorProtoSchema)` to create a new message. + */ +export const FieldDescriptorProtoSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 4); +/** + * @generated from enum google.protobuf.FieldDescriptorProto.Type + */ +export var FieldDescriptorProto_Type; +(function (FieldDescriptorProto_Type) { + /** + * 0 is reserved for errors. + * Order is weird for historical reasons. + * + * @generated from enum value: TYPE_DOUBLE = 1; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["DOUBLE"] = 1] = "DOUBLE"; + /** + * @generated from enum value: TYPE_FLOAT = 2; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["FLOAT"] = 2] = "FLOAT"; + /** + * Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + * negative values are likely. + * + * @generated from enum value: TYPE_INT64 = 3; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["INT64"] = 3] = "INT64"; + /** + * @generated from enum value: TYPE_UINT64 = 4; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["UINT64"] = 4] = "UINT64"; + /** + * Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + * negative values are likely. + * + * @generated from enum value: TYPE_INT32 = 5; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["INT32"] = 5] = "INT32"; + /** + * @generated from enum value: TYPE_FIXED64 = 6; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["FIXED64"] = 6] = "FIXED64"; + /** + * @generated from enum value: TYPE_FIXED32 = 7; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["FIXED32"] = 7] = "FIXED32"; + /** + * @generated from enum value: TYPE_BOOL = 8; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["BOOL"] = 8] = "BOOL"; + /** + * @generated from enum value: TYPE_STRING = 9; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["STRING"] = 9] = "STRING"; + /** + * Tag-delimited aggregate. + * Group type is deprecated and not supported after google.protobuf. However, Proto3 + * implementations should still be able to parse the group wire format and + * treat group fields as unknown fields. In Editions, the group wire format + * can be enabled via the `message_encoding` feature. + * + * @generated from enum value: TYPE_GROUP = 10; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["GROUP"] = 10] = "GROUP"; + /** + * Length-delimited aggregate. + * + * @generated from enum value: TYPE_MESSAGE = 11; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["MESSAGE"] = 11] = "MESSAGE"; + /** + * New in version 2. + * + * @generated from enum value: TYPE_BYTES = 12; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["BYTES"] = 12] = "BYTES"; + /** + * @generated from enum value: TYPE_UINT32 = 13; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["UINT32"] = 13] = "UINT32"; + /** + * @generated from enum value: TYPE_ENUM = 14; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["ENUM"] = 14] = "ENUM"; + /** + * @generated from enum value: TYPE_SFIXED32 = 15; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["SFIXED32"] = 15] = "SFIXED32"; + /** + * @generated from enum value: TYPE_SFIXED64 = 16; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["SFIXED64"] = 16] = "SFIXED64"; + /** + * Uses ZigZag encoding. + * + * @generated from enum value: TYPE_SINT32 = 17; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["SINT32"] = 17] = "SINT32"; + /** + * Uses ZigZag encoding. + * + * @generated from enum value: TYPE_SINT64 = 18; + */ + FieldDescriptorProto_Type[FieldDescriptorProto_Type["SINT64"] = 18] = "SINT64"; +})(FieldDescriptorProto_Type || (FieldDescriptorProto_Type = {})); +/** + * Describes the enum google.protobuf.FieldDescriptorProto.Type. + */ +export const FieldDescriptorProto_TypeSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 4, 0); +/** + * @generated from enum google.protobuf.FieldDescriptorProto.Label + */ +export var FieldDescriptorProto_Label; +(function (FieldDescriptorProto_Label) { + /** + * 0 is reserved for errors + * + * @generated from enum value: LABEL_OPTIONAL = 1; + */ + FieldDescriptorProto_Label[FieldDescriptorProto_Label["OPTIONAL"] = 1] = "OPTIONAL"; + /** + * @generated from enum value: LABEL_REPEATED = 3; + */ + FieldDescriptorProto_Label[FieldDescriptorProto_Label["REPEATED"] = 3] = "REPEATED"; + /** + * The required label is only allowed in google.protobuf. In proto3 and Editions + * it's explicitly prohibited. In Editions, the `field_presence` feature + * can be used to get this behavior. + * + * @generated from enum value: LABEL_REQUIRED = 2; + */ + FieldDescriptorProto_Label[FieldDescriptorProto_Label["REQUIRED"] = 2] = "REQUIRED"; +})(FieldDescriptorProto_Label || (FieldDescriptorProto_Label = {})); +/** + * Describes the enum google.protobuf.FieldDescriptorProto.Label. + */ +export const FieldDescriptorProto_LabelSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 4, 1); +/** + * Describes the message google.protobuf.OneofDescriptorProto. + * Use `create(OneofDescriptorProtoSchema)` to create a new message. + */ +export const OneofDescriptorProtoSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 5); +/** + * Describes the message google.protobuf.EnumDescriptorProto. + * Use `create(EnumDescriptorProtoSchema)` to create a new message. + */ +export const EnumDescriptorProtoSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 6); +/** + * Describes the message google.protobuf.EnumDescriptorProto.EnumReservedRange. + * Use `create(EnumDescriptorProto_EnumReservedRangeSchema)` to create a new message. + */ +export const EnumDescriptorProto_EnumReservedRangeSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 6, 0); +/** + * Describes the message google.protobuf.EnumValueDescriptorProto. + * Use `create(EnumValueDescriptorProtoSchema)` to create a new message. + */ +export const EnumValueDescriptorProtoSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 7); +/** + * Describes the message google.protobuf.ServiceDescriptorProto. + * Use `create(ServiceDescriptorProtoSchema)` to create a new message. + */ +export const ServiceDescriptorProtoSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 8); +/** + * Describes the message google.protobuf.MethodDescriptorProto. + * Use `create(MethodDescriptorProtoSchema)` to create a new message. + */ +export const MethodDescriptorProtoSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 9); +/** + * Describes the message google.protobuf.FileOptions. + * Use `create(FileOptionsSchema)` to create a new message. + */ +export const FileOptionsSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 10); +/** + * Generated classes can be optimized for speed or code size. + * + * @generated from enum google.protobuf.FileOptions.OptimizeMode + */ +export var FileOptions_OptimizeMode; +(function (FileOptions_OptimizeMode) { + /** + * Generate complete code for parsing, serialization, + * + * @generated from enum value: SPEED = 1; + */ + FileOptions_OptimizeMode[FileOptions_OptimizeMode["SPEED"] = 1] = "SPEED"; + /** + * etc. + * + * Use ReflectionOps to implement these methods. + * + * @generated from enum value: CODE_SIZE = 2; + */ + FileOptions_OptimizeMode[FileOptions_OptimizeMode["CODE_SIZE"] = 2] = "CODE_SIZE"; + /** + * Generate code using MessageLite and the lite runtime. + * + * @generated from enum value: LITE_RUNTIME = 3; + */ + FileOptions_OptimizeMode[FileOptions_OptimizeMode["LITE_RUNTIME"] = 3] = "LITE_RUNTIME"; +})(FileOptions_OptimizeMode || (FileOptions_OptimizeMode = {})); +/** + * Describes the enum google.protobuf.FileOptions.OptimizeMode. + */ +export const FileOptions_OptimizeModeSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 10, 0); +/** + * Describes the message google.protobuf.MessageOptions. + * Use `create(MessageOptionsSchema)` to create a new message. + */ +export const MessageOptionsSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 11); +/** + * Describes the message google.protobuf.FieldOptions. + * Use `create(FieldOptionsSchema)` to create a new message. + */ +export const FieldOptionsSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 12); +/** + * Describes the message google.protobuf.FieldOptions.EditionDefault. + * Use `create(FieldOptions_EditionDefaultSchema)` to create a new message. + */ +export const FieldOptions_EditionDefaultSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 12, 0); +/** + * Describes the message google.protobuf.FieldOptions.FeatureSupport. + * Use `create(FieldOptions_FeatureSupportSchema)` to create a new message. + */ +export const FieldOptions_FeatureSupportSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 12, 1); +/** + * @generated from enum google.protobuf.FieldOptions.CType + */ +export var FieldOptions_CType; +(function (FieldOptions_CType) { + /** + * Default mode. + * + * @generated from enum value: STRING = 0; + */ + FieldOptions_CType[FieldOptions_CType["STRING"] = 0] = "STRING"; + /** + * The option [ctype=CORD] may be applied to a non-repeated field of type + * "bytes". It indicates that in C++, the data should be stored in a Cord + * instead of a string. For very large strings, this may reduce memory + * fragmentation. It may also allow better performance when parsing from a + * Cord, or when parsing with aliasing enabled, as the parsed Cord may then + * alias the original buffer. + * + * @generated from enum value: CORD = 1; + */ + FieldOptions_CType[FieldOptions_CType["CORD"] = 1] = "CORD"; + /** + * @generated from enum value: STRING_PIECE = 2; + */ + FieldOptions_CType[FieldOptions_CType["STRING_PIECE"] = 2] = "STRING_PIECE"; +})(FieldOptions_CType || (FieldOptions_CType = {})); +/** + * Describes the enum google.protobuf.FieldOptions.CType. + */ +export const FieldOptions_CTypeSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 12, 0); +/** + * @generated from enum google.protobuf.FieldOptions.JSType + */ +export var FieldOptions_JSType; +(function (FieldOptions_JSType) { + /** + * Use the default type. + * + * @generated from enum value: JS_NORMAL = 0; + */ + FieldOptions_JSType[FieldOptions_JSType["JS_NORMAL"] = 0] = "JS_NORMAL"; + /** + * Use JavaScript strings. + * + * @generated from enum value: JS_STRING = 1; + */ + FieldOptions_JSType[FieldOptions_JSType["JS_STRING"] = 1] = "JS_STRING"; + /** + * Use JavaScript numbers. + * + * @generated from enum value: JS_NUMBER = 2; + */ + FieldOptions_JSType[FieldOptions_JSType["JS_NUMBER"] = 2] = "JS_NUMBER"; +})(FieldOptions_JSType || (FieldOptions_JSType = {})); +/** + * Describes the enum google.protobuf.FieldOptions.JSType. + */ +export const FieldOptions_JSTypeSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 12, 1); +/** + * If set to RETENTION_SOURCE, the option will be omitted from the binary. + * + * @generated from enum google.protobuf.FieldOptions.OptionRetention + */ +export var FieldOptions_OptionRetention; +(function (FieldOptions_OptionRetention) { + /** + * @generated from enum value: RETENTION_UNKNOWN = 0; + */ + FieldOptions_OptionRetention[FieldOptions_OptionRetention["RETENTION_UNKNOWN"] = 0] = "RETENTION_UNKNOWN"; + /** + * @generated from enum value: RETENTION_RUNTIME = 1; + */ + FieldOptions_OptionRetention[FieldOptions_OptionRetention["RETENTION_RUNTIME"] = 1] = "RETENTION_RUNTIME"; + /** + * @generated from enum value: RETENTION_SOURCE = 2; + */ + FieldOptions_OptionRetention[FieldOptions_OptionRetention["RETENTION_SOURCE"] = 2] = "RETENTION_SOURCE"; +})(FieldOptions_OptionRetention || (FieldOptions_OptionRetention = {})); +/** + * Describes the enum google.protobuf.FieldOptions.OptionRetention. + */ +export const FieldOptions_OptionRetentionSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 12, 2); +/** + * This indicates the types of entities that the field may apply to when used + * as an option. If it is unset, then the field may be freely used as an + * option on any kind of entity. + * + * @generated from enum google.protobuf.FieldOptions.OptionTargetType + */ +export var FieldOptions_OptionTargetType; +(function (FieldOptions_OptionTargetType) { + /** + * @generated from enum value: TARGET_TYPE_UNKNOWN = 0; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_UNKNOWN"] = 0] = "TARGET_TYPE_UNKNOWN"; + /** + * @generated from enum value: TARGET_TYPE_FILE = 1; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_FILE"] = 1] = "TARGET_TYPE_FILE"; + /** + * @generated from enum value: TARGET_TYPE_EXTENSION_RANGE = 2; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_EXTENSION_RANGE"] = 2] = "TARGET_TYPE_EXTENSION_RANGE"; + /** + * @generated from enum value: TARGET_TYPE_MESSAGE = 3; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_MESSAGE"] = 3] = "TARGET_TYPE_MESSAGE"; + /** + * @generated from enum value: TARGET_TYPE_FIELD = 4; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_FIELD"] = 4] = "TARGET_TYPE_FIELD"; + /** + * @generated from enum value: TARGET_TYPE_ONEOF = 5; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_ONEOF"] = 5] = "TARGET_TYPE_ONEOF"; + /** + * @generated from enum value: TARGET_TYPE_ENUM = 6; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_ENUM"] = 6] = "TARGET_TYPE_ENUM"; + /** + * @generated from enum value: TARGET_TYPE_ENUM_ENTRY = 7; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_ENUM_ENTRY"] = 7] = "TARGET_TYPE_ENUM_ENTRY"; + /** + * @generated from enum value: TARGET_TYPE_SERVICE = 8; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_SERVICE"] = 8] = "TARGET_TYPE_SERVICE"; + /** + * @generated from enum value: TARGET_TYPE_METHOD = 9; + */ + FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_METHOD"] = 9] = "TARGET_TYPE_METHOD"; +})(FieldOptions_OptionTargetType || (FieldOptions_OptionTargetType = {})); +/** + * Describes the enum google.protobuf.FieldOptions.OptionTargetType. + */ +export const FieldOptions_OptionTargetTypeSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 12, 3); +/** + * Describes the message google.protobuf.OneofOptions. + * Use `create(OneofOptionsSchema)` to create a new message. + */ +export const OneofOptionsSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 13); +/** + * Describes the message google.protobuf.EnumOptions. + * Use `create(EnumOptionsSchema)` to create a new message. + */ +export const EnumOptionsSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 14); +/** + * Describes the message google.protobuf.EnumValueOptions. + * Use `create(EnumValueOptionsSchema)` to create a new message. + */ +export const EnumValueOptionsSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 15); +/** + * Describes the message google.protobuf.ServiceOptions. + * Use `create(ServiceOptionsSchema)` to create a new message. + */ +export const ServiceOptionsSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 16); +/** + * Describes the message google.protobuf.MethodOptions. + * Use `create(MethodOptionsSchema)` to create a new message. + */ +export const MethodOptionsSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 17); +/** + * Is this method side-effect-free (or safe in HTTP parlance), or idempotent, + * or neither? HTTP based RPC implementation may choose GET verb for safe + * methods, and PUT verb for idempotent methods instead of the default POST. + * + * @generated from enum google.protobuf.MethodOptions.IdempotencyLevel + */ +export var MethodOptions_IdempotencyLevel; +(function (MethodOptions_IdempotencyLevel) { + /** + * @generated from enum value: IDEMPOTENCY_UNKNOWN = 0; + */ + MethodOptions_IdempotencyLevel[MethodOptions_IdempotencyLevel["IDEMPOTENCY_UNKNOWN"] = 0] = "IDEMPOTENCY_UNKNOWN"; + /** + * implies idempotent + * + * @generated from enum value: NO_SIDE_EFFECTS = 1; + */ + MethodOptions_IdempotencyLevel[MethodOptions_IdempotencyLevel["NO_SIDE_EFFECTS"] = 1] = "NO_SIDE_EFFECTS"; + /** + * idempotent, but may have side effects + * + * @generated from enum value: IDEMPOTENT = 2; + */ + MethodOptions_IdempotencyLevel[MethodOptions_IdempotencyLevel["IDEMPOTENT"] = 2] = "IDEMPOTENT"; +})(MethodOptions_IdempotencyLevel || (MethodOptions_IdempotencyLevel = {})); +/** + * Describes the enum google.protobuf.MethodOptions.IdempotencyLevel. + */ +export const MethodOptions_IdempotencyLevelSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 17, 0); +/** + * Describes the message google.protobuf.UninterpretedOption. + * Use `create(UninterpretedOptionSchema)` to create a new message. + */ +export const UninterpretedOptionSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 18); +/** + * Describes the message google.protobuf.UninterpretedOption.NamePart. + * Use `create(UninterpretedOption_NamePartSchema)` to create a new message. + */ +export const UninterpretedOption_NamePartSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 18, 0); +/** + * Describes the message google.protobuf.FeatureSet. + * Use `create(FeatureSetSchema)` to create a new message. + */ +export const FeatureSetSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 19); +/** + * Describes the message google.protobuf.FeatureSet.VisibilityFeature. + * Use `create(FeatureSet_VisibilityFeatureSchema)` to create a new message. + */ +export const FeatureSet_VisibilityFeatureSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 19, 0); +/** + * @generated from enum google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility + */ +export var FeatureSet_VisibilityFeature_DefaultSymbolVisibility; +(function (FeatureSet_VisibilityFeature_DefaultSymbolVisibility) { + /** + * @generated from enum value: DEFAULT_SYMBOL_VISIBILITY_UNKNOWN = 0; + */ + FeatureSet_VisibilityFeature_DefaultSymbolVisibility[FeatureSet_VisibilityFeature_DefaultSymbolVisibility["DEFAULT_SYMBOL_VISIBILITY_UNKNOWN"] = 0] = "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN"; + /** + * Default pre-EDITION_2024, all UNSET visibility are export. + * + * @generated from enum value: EXPORT_ALL = 1; + */ + FeatureSet_VisibilityFeature_DefaultSymbolVisibility[FeatureSet_VisibilityFeature_DefaultSymbolVisibility["EXPORT_ALL"] = 1] = "EXPORT_ALL"; + /** + * All top-level symbols default to export, nested default to local. + * + * @generated from enum value: EXPORT_TOP_LEVEL = 2; + */ + FeatureSet_VisibilityFeature_DefaultSymbolVisibility[FeatureSet_VisibilityFeature_DefaultSymbolVisibility["EXPORT_TOP_LEVEL"] = 2] = "EXPORT_TOP_LEVEL"; + /** + * All symbols default to local. + * + * @generated from enum value: LOCAL_ALL = 3; + */ + FeatureSet_VisibilityFeature_DefaultSymbolVisibility[FeatureSet_VisibilityFeature_DefaultSymbolVisibility["LOCAL_ALL"] = 3] = "LOCAL_ALL"; + /** + * All symbols local by default. Nested types cannot be exported. + * With special case caveat for message { enum {} reserved 1 to max; } + * This is the recommended setting for new protos. + * + * @generated from enum value: STRICT = 4; + */ + FeatureSet_VisibilityFeature_DefaultSymbolVisibility[FeatureSet_VisibilityFeature_DefaultSymbolVisibility["STRICT"] = 4] = "STRICT"; +})(FeatureSet_VisibilityFeature_DefaultSymbolVisibility || (FeatureSet_VisibilityFeature_DefaultSymbolVisibility = {})); +/** + * Describes the enum google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility. + */ +export const FeatureSet_VisibilityFeature_DefaultSymbolVisibilitySchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 19, 0, 0); +/** + * @generated from enum google.protobuf.FeatureSet.FieldPresence + */ +export var FeatureSet_FieldPresence; +(function (FeatureSet_FieldPresence) { + /** + * @generated from enum value: FIELD_PRESENCE_UNKNOWN = 0; + */ + FeatureSet_FieldPresence[FeatureSet_FieldPresence["FIELD_PRESENCE_UNKNOWN"] = 0] = "FIELD_PRESENCE_UNKNOWN"; + /** + * @generated from enum value: EXPLICIT = 1; + */ + FeatureSet_FieldPresence[FeatureSet_FieldPresence["EXPLICIT"] = 1] = "EXPLICIT"; + /** + * @generated from enum value: IMPLICIT = 2; + */ + FeatureSet_FieldPresence[FeatureSet_FieldPresence["IMPLICIT"] = 2] = "IMPLICIT"; + /** + * @generated from enum value: LEGACY_REQUIRED = 3; + */ + FeatureSet_FieldPresence[FeatureSet_FieldPresence["LEGACY_REQUIRED"] = 3] = "LEGACY_REQUIRED"; +})(FeatureSet_FieldPresence || (FeatureSet_FieldPresence = {})); +/** + * Describes the enum google.protobuf.FeatureSet.FieldPresence. + */ +export const FeatureSet_FieldPresenceSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 19, 0); +/** + * @generated from enum google.protobuf.FeatureSet.EnumType + */ +export var FeatureSet_EnumType; +(function (FeatureSet_EnumType) { + /** + * @generated from enum value: ENUM_TYPE_UNKNOWN = 0; + */ + FeatureSet_EnumType[FeatureSet_EnumType["ENUM_TYPE_UNKNOWN"] = 0] = "ENUM_TYPE_UNKNOWN"; + /** + * @generated from enum value: OPEN = 1; + */ + FeatureSet_EnumType[FeatureSet_EnumType["OPEN"] = 1] = "OPEN"; + /** + * @generated from enum value: CLOSED = 2; + */ + FeatureSet_EnumType[FeatureSet_EnumType["CLOSED"] = 2] = "CLOSED"; +})(FeatureSet_EnumType || (FeatureSet_EnumType = {})); +/** + * Describes the enum google.protobuf.FeatureSet.EnumType. + */ +export const FeatureSet_EnumTypeSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 19, 1); +/** + * @generated from enum google.protobuf.FeatureSet.RepeatedFieldEncoding + */ +export var FeatureSet_RepeatedFieldEncoding; +(function (FeatureSet_RepeatedFieldEncoding) { + /** + * @generated from enum value: REPEATED_FIELD_ENCODING_UNKNOWN = 0; + */ + FeatureSet_RepeatedFieldEncoding[FeatureSet_RepeatedFieldEncoding["REPEATED_FIELD_ENCODING_UNKNOWN"] = 0] = "REPEATED_FIELD_ENCODING_UNKNOWN"; + /** + * @generated from enum value: PACKED = 1; + */ + FeatureSet_RepeatedFieldEncoding[FeatureSet_RepeatedFieldEncoding["PACKED"] = 1] = "PACKED"; + /** + * @generated from enum value: EXPANDED = 2; + */ + FeatureSet_RepeatedFieldEncoding[FeatureSet_RepeatedFieldEncoding["EXPANDED"] = 2] = "EXPANDED"; +})(FeatureSet_RepeatedFieldEncoding || (FeatureSet_RepeatedFieldEncoding = {})); +/** + * Describes the enum google.protobuf.FeatureSet.RepeatedFieldEncoding. + */ +export const FeatureSet_RepeatedFieldEncodingSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 19, 2); +/** + * @generated from enum google.protobuf.FeatureSet.Utf8Validation + */ +export var FeatureSet_Utf8Validation; +(function (FeatureSet_Utf8Validation) { + /** + * @generated from enum value: UTF8_VALIDATION_UNKNOWN = 0; + */ + FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["UTF8_VALIDATION_UNKNOWN"] = 0] = "UTF8_VALIDATION_UNKNOWN"; + /** + * @generated from enum value: VERIFY = 2; + */ + FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["VERIFY"] = 2] = "VERIFY"; + /** + * @generated from enum value: NONE = 3; + */ + FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["NONE"] = 3] = "NONE"; +})(FeatureSet_Utf8Validation || (FeatureSet_Utf8Validation = {})); +/** + * Describes the enum google.protobuf.FeatureSet.Utf8Validation. + */ +export const FeatureSet_Utf8ValidationSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 19, 3); +/** + * @generated from enum google.protobuf.FeatureSet.MessageEncoding + */ +export var FeatureSet_MessageEncoding; +(function (FeatureSet_MessageEncoding) { + /** + * @generated from enum value: MESSAGE_ENCODING_UNKNOWN = 0; + */ + FeatureSet_MessageEncoding[FeatureSet_MessageEncoding["MESSAGE_ENCODING_UNKNOWN"] = 0] = "MESSAGE_ENCODING_UNKNOWN"; + /** + * @generated from enum value: LENGTH_PREFIXED = 1; + */ + FeatureSet_MessageEncoding[FeatureSet_MessageEncoding["LENGTH_PREFIXED"] = 1] = "LENGTH_PREFIXED"; + /** + * @generated from enum value: DELIMITED = 2; + */ + FeatureSet_MessageEncoding[FeatureSet_MessageEncoding["DELIMITED"] = 2] = "DELIMITED"; +})(FeatureSet_MessageEncoding || (FeatureSet_MessageEncoding = {})); +/** + * Describes the enum google.protobuf.FeatureSet.MessageEncoding. + */ +export const FeatureSet_MessageEncodingSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 19, 4); +/** + * @generated from enum google.protobuf.FeatureSet.JsonFormat + */ +export var FeatureSet_JsonFormat; +(function (FeatureSet_JsonFormat) { + /** + * @generated from enum value: JSON_FORMAT_UNKNOWN = 0; + */ + FeatureSet_JsonFormat[FeatureSet_JsonFormat["JSON_FORMAT_UNKNOWN"] = 0] = "JSON_FORMAT_UNKNOWN"; + /** + * @generated from enum value: ALLOW = 1; + */ + FeatureSet_JsonFormat[FeatureSet_JsonFormat["ALLOW"] = 1] = "ALLOW"; + /** + * @generated from enum value: LEGACY_BEST_EFFORT = 2; + */ + FeatureSet_JsonFormat[FeatureSet_JsonFormat["LEGACY_BEST_EFFORT"] = 2] = "LEGACY_BEST_EFFORT"; +})(FeatureSet_JsonFormat || (FeatureSet_JsonFormat = {})); +/** + * Describes the enum google.protobuf.FeatureSet.JsonFormat. + */ +export const FeatureSet_JsonFormatSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 19, 5); +/** + * @generated from enum google.protobuf.FeatureSet.EnforceNamingStyle + */ +export var FeatureSet_EnforceNamingStyle; +(function (FeatureSet_EnforceNamingStyle) { + /** + * @generated from enum value: ENFORCE_NAMING_STYLE_UNKNOWN = 0; + */ + FeatureSet_EnforceNamingStyle[FeatureSet_EnforceNamingStyle["ENFORCE_NAMING_STYLE_UNKNOWN"] = 0] = "ENFORCE_NAMING_STYLE_UNKNOWN"; + /** + * @generated from enum value: STYLE2024 = 1; + */ + FeatureSet_EnforceNamingStyle[FeatureSet_EnforceNamingStyle["STYLE2024"] = 1] = "STYLE2024"; + /** + * @generated from enum value: STYLE_LEGACY = 2; + */ + FeatureSet_EnforceNamingStyle[FeatureSet_EnforceNamingStyle["STYLE_LEGACY"] = 2] = "STYLE_LEGACY"; +})(FeatureSet_EnforceNamingStyle || (FeatureSet_EnforceNamingStyle = {})); +/** + * Describes the enum google.protobuf.FeatureSet.EnforceNamingStyle. + */ +export const FeatureSet_EnforceNamingStyleSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 19, 6); +/** + * Describes the message google.protobuf.FeatureSetDefaults. + * Use `create(FeatureSetDefaultsSchema)` to create a new message. + */ +export const FeatureSetDefaultsSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 20); +/** + * Describes the message google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault. + * Use `create(FeatureSetDefaults_FeatureSetEditionDefaultSchema)` to create a new message. + */ +export const FeatureSetDefaults_FeatureSetEditionDefaultSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 20, 0); +/** + * Describes the message google.protobuf.SourceCodeInfo. + * Use `create(SourceCodeInfoSchema)` to create a new message. + */ +export const SourceCodeInfoSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 21); +/** + * Describes the message google.protobuf.SourceCodeInfo.Location. + * Use `create(SourceCodeInfo_LocationSchema)` to create a new message. + */ +export const SourceCodeInfo_LocationSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 21, 0); +/** + * Describes the message google.protobuf.GeneratedCodeInfo. + * Use `create(GeneratedCodeInfoSchema)` to create a new message. + */ +export const GeneratedCodeInfoSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 22); +/** + * Describes the message google.protobuf.GeneratedCodeInfo.Annotation. + * Use `create(GeneratedCodeInfo_AnnotationSchema)` to create a new message. + */ +export const GeneratedCodeInfo_AnnotationSchema = /*@__PURE__*/ messageDesc(file_google_protobuf_descriptor, 22, 0); +/** + * Represents the identified object's effect on the element in the original + * .proto file. + * + * @generated from enum google.protobuf.GeneratedCodeInfo.Annotation.Semantic + */ +export var GeneratedCodeInfo_Annotation_Semantic; +(function (GeneratedCodeInfo_Annotation_Semantic) { + /** + * There is no effect or the effect is indescribable. + * + * @generated from enum value: NONE = 0; + */ + GeneratedCodeInfo_Annotation_Semantic[GeneratedCodeInfo_Annotation_Semantic["NONE"] = 0] = "NONE"; + /** + * The element is set or otherwise mutated. + * + * @generated from enum value: SET = 1; + */ + GeneratedCodeInfo_Annotation_Semantic[GeneratedCodeInfo_Annotation_Semantic["SET"] = 1] = "SET"; + /** + * An alias to the element is returned. + * + * @generated from enum value: ALIAS = 2; + */ + GeneratedCodeInfo_Annotation_Semantic[GeneratedCodeInfo_Annotation_Semantic["ALIAS"] = 2] = "ALIAS"; +})(GeneratedCodeInfo_Annotation_Semantic || (GeneratedCodeInfo_Annotation_Semantic = {})); +/** + * Describes the enum google.protobuf.GeneratedCodeInfo.Annotation.Semantic. + */ +export const GeneratedCodeInfo_Annotation_SemanticSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 22, 0, 0); +/** + * The full set of known editions. + * + * @generated from enum google.protobuf.Edition + */ +export var Edition; +(function (Edition) { + /** + * A placeholder for an unknown edition value. + * + * @generated from enum value: EDITION_UNKNOWN = 0; + */ + Edition[Edition["EDITION_UNKNOWN"] = 0] = "EDITION_UNKNOWN"; + /** + * A placeholder edition for specifying default behaviors *before* a feature + * was first introduced. This is effectively an "infinite past". + * + * @generated from enum value: EDITION_LEGACY = 900; + */ + Edition[Edition["EDITION_LEGACY"] = 900] = "EDITION_LEGACY"; + /** + * Legacy syntax "editions". These pre-date editions, but behave much like + * distinct editions. These can't be used to specify the edition of proto + * files, but feature definitions must supply proto2/proto3 defaults for + * backwards compatibility. + * + * @generated from enum value: EDITION_PROTO2 = 998; + */ + Edition[Edition["EDITION_PROTO2"] = 998] = "EDITION_PROTO2"; + /** + * @generated from enum value: EDITION_PROTO3 = 999; + */ + Edition[Edition["EDITION_PROTO3"] = 999] = "EDITION_PROTO3"; + /** + * Editions that have been released. The specific values are arbitrary and + * should not be depended on, but they will always be time-ordered for easy + * comparison. + * + * @generated from enum value: EDITION_2023 = 1000; + */ + Edition[Edition["EDITION_2023"] = 1000] = "EDITION_2023"; + /** + * @generated from enum value: EDITION_2024 = 1001; + */ + Edition[Edition["EDITION_2024"] = 1001] = "EDITION_2024"; + /** + * Placeholder editions for testing feature resolution. These should not be + * used or relied on outside of tests. + * + * @generated from enum value: EDITION_1_TEST_ONLY = 1; + */ + Edition[Edition["EDITION_1_TEST_ONLY"] = 1] = "EDITION_1_TEST_ONLY"; + /** + * @generated from enum value: EDITION_2_TEST_ONLY = 2; + */ + Edition[Edition["EDITION_2_TEST_ONLY"] = 2] = "EDITION_2_TEST_ONLY"; + /** + * @generated from enum value: EDITION_99997_TEST_ONLY = 99997; + */ + Edition[Edition["EDITION_99997_TEST_ONLY"] = 99997] = "EDITION_99997_TEST_ONLY"; + /** + * @generated from enum value: EDITION_99998_TEST_ONLY = 99998; + */ + Edition[Edition["EDITION_99998_TEST_ONLY"] = 99998] = "EDITION_99998_TEST_ONLY"; + /** + * @generated from enum value: EDITION_99999_TEST_ONLY = 99999; + */ + Edition[Edition["EDITION_99999_TEST_ONLY"] = 99999] = "EDITION_99999_TEST_ONLY"; + /** + * Placeholder for specifying unbounded edition support. This should only + * ever be used by plugins that can expect to never require any changes to + * support a new edition. + * + * @generated from enum value: EDITION_MAX = 2147483647; + */ + Edition[Edition["EDITION_MAX"] = 2147483647] = "EDITION_MAX"; +})(Edition || (Edition = {})); +/** + * Describes the enum google.protobuf.Edition. + */ +export const EditionSchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 0); +/** + * Describes the 'visibility' of a symbol with respect to the proto import + * system. Symbols can only be imported when the visibility rules do not prevent + * it (ex: local symbols cannot be imported). Visibility modifiers can only set + * on `message` and `enum` as they are the only types available to be referenced + * from other files. + * + * @generated from enum google.protobuf.SymbolVisibility + */ +export var SymbolVisibility; +(function (SymbolVisibility) { + /** + * @generated from enum value: VISIBILITY_UNSET = 0; + */ + SymbolVisibility[SymbolVisibility["VISIBILITY_UNSET"] = 0] = "VISIBILITY_UNSET"; + /** + * @generated from enum value: VISIBILITY_LOCAL = 1; + */ + SymbolVisibility[SymbolVisibility["VISIBILITY_LOCAL"] = 1] = "VISIBILITY_LOCAL"; + /** + * @generated from enum value: VISIBILITY_EXPORT = 2; + */ + SymbolVisibility[SymbolVisibility["VISIBILITY_EXPORT"] = 2] = "VISIBILITY_EXPORT"; +})(SymbolVisibility || (SymbolVisibility = {})); +/** + * Describes the enum google.protobuf.SymbolVisibility. + */ +export const SymbolVisibilitySchema = /*@__PURE__*/ enumDesc(file_google_protobuf_descriptor, 1); diff --git a/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/duration_pb.d.ts b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/duration_pb.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a779ebf2c3ea59b8969fa97663a6a7ecb5c29cb2 --- /dev/null +++ b/node_modules/.pnpm/@bufbuild+protobuf@2.7.0/node_modules/@bufbuild/protobuf/dist/esm/wkt/gen/google/protobuf/duration_pb.d.ts @@ -0,0 +1,161 @@ +import type { GenFile, GenMessage } from "../../../../codegenv2/types.js"; +import type { Message } from "../../../../types.js"; +/** + * Describes the file google/protobuf/duration.proto. + */ +export declare const file_google_protobuf_duration: GenFile; +/** + * A Duration represents a signed, fixed-length span of time represented + * as a count of seconds and fractions of seconds at nanosecond + * resolution. It is independent of any calendar and concepts like "day" + * or "month". It is related to Timestamp in that the difference between + * two Timestamp values is a Duration and it can be added or subtracted + * from a Timestamp. Range is approximately +-10,000 years. + * + * # Examples + * + * Example 1: Compute Duration from two Timestamps in pseudo code. + * + * Timestamp start = ...; + * Timestamp end = ...; + * Duration duration = ...; + * + * duration.seconds = end.seconds - start.seconds; + * duration.nanos = end.nanos - start.nanos; + * + * if (duration.seconds < 0 && duration.nanos > 0) { + * duration.seconds += 1; + * duration.nanos -= 1000000000; + * } else if (duration.seconds > 0 && duration.nanos < 0) { + * duration.seconds -= 1; + * duration.nanos += 1000000000; + * } + * + * Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. + * + * Timestamp start = ...; + * Duration duration = ...; + * Timestamp end = ...; + * + * end.seconds = start.seconds + duration.seconds; + * end.nanos = start.nanos + duration.nanos; + * + * if (end.nanos < 0) { + * end.seconds -= 1; + * end.nanos += 1000000000; + * } else if (end.nanos >= 1000000000) { + * end.seconds += 1; + * end.nanos -= 1000000000; + * } + * + * Example 3: Compute Duration from datetime.timedelta in Python. + * + * td = datetime.timedelta(days=3, minutes=10) + * duration = Duration() + * duration.FromTimedelta(td) + * + * # JSON Mapping + * + * In JSON format, the Duration type is encoded as a string rather than an + * object, where the string ends in the suffix "s" (indicating seconds) and + * is preceded by the number of seconds, with nanoseconds expressed as + * fractional seconds. For example, 3 seconds with 0 nanoseconds should be + * encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should + * be expressed in JSON format as "3.000000001s", and 3 seconds and 1 + * microsecond should be expressed in JSON format as "3.000001s". + * + * + * @generated from message google.protobuf.Duration + */ +export type Duration = Message<"google.protobuf.Duration"> & { + /** + * Signed seconds of the span of time. Must be from -315,576,000,000 + * to +315,576,000,000 inclusive. Note: these bounds are computed from: + * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years + * + * @generated from field: int64 seconds = 1; + */ + seconds: bigint; + /** + * Signed fractions of a second at nanosecond resolution of the span + * of time. Durations less than one second are represented with a 0 + * `seconds` field and a positive or negative `nanos` field. For durations + * of one second or more, a non-zero value for the `nanos` field must be + * of the same sign as the `seconds` field. Must be from -999,999,999 + * to +999,999,999 inclusive. + * + * @generated from field: int32 nanos = 2; + */ + nanos: number; +}; +/** + * A Duration represents a signed, fixed-length span of time represented + * as a count of seconds and fractions of seconds at nanosecond + * resolution. It is independent of any calendar and concepts like "day" + * or "month". It is related to Timestamp in that the difference between + * two Timestamp values is a Duration and it can be added or subtracted + * from a Timestamp. Range is approximately +-10,000 years. + * + * # Examples + * + * Example 1: Compute Duration from two Timestamps in pseudo code. + * + * Timestamp start = ...; + * Timestamp end = ...; + * Duration duration = ...; + * + * duration.seconds = end.seconds - start.seconds; + * duration.nanos = end.nanos - start.nanos; + * + * if (duration.seconds < 0 && duration.nanos > 0) { + * duration.seconds += 1; + * duration.nanos -= 1000000000; + * } else if (duration.seconds > 0 && duration.nanos < 0) { + * duration.seconds -= 1; + * duration.nanos += 1000000000; + * } + * + * Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. + * + * Timestamp start = ...; + * Duration duration = ...; + * Timestamp end = ...; + * + * end.seconds = start.seconds + duration.seconds; + * end.nanos = start.nanos + duration.nanos; + * + * if (end.nanos < 0) { + * end.seconds -= 1; + * end.nanos += 1000000000; + * } else if (end.nanos >= 1000000000) { + * end.seconds += 1; + * end.nanos -= 1000000000; + * } + * + * Example 3: Compute Duration from datetime.timedelta in Python. + * + * td = datetime.timedelta(days=3, minutes=10) + * duration = Duration() + * duration.FromTimedelta(td) + * + * # JSON Mapping + * + * In JSON format, the Duration type is encoded as a string rather than an + * object, where the string ends in the suffix "s" (indicating seconds) and + * is preceded by the number of seconds, with nanoseconds expressed as + * fractional seconds. For example, 3 seconds with 0 nanoseconds should be + * encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should + * be expressed in JSON format as "3.000000001s", and 3 seconds and 1 + * microsecond should be expressed in JSON format as "3.000001s". + * + * + * @generated from message google.protobuf.Duration + */ +export type DurationJson = string; +/** + * Describes the message google.protobuf.Duration. + * Use `create(DurationSchema)` to create a new message. + */ +export declare const DurationSchema: GenMessage;