@relyio/sdk 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,523 @@
+export { N as AdhocAggregateBlock, M as AdhocFetchBlock, L as AdhocQueryBuilder, K as AdhocQueryClient, W as AdhocQueryDefinition, X as AdhocQueryOptions, Z as AdhocQueryResult, P as AdhocSearchBlock, Q as AdhocSimilarBlock, O as AggregateMetric, _ as AssetClient, a8 as AssetEntryResponse, a5 as AssetFileBlock, $ as AssetFileBuilder, a6 as AssetFileExtracted, a0 as AssetUploadBuilder, a7 as AssetUrls, a2 as AssetVisibility, A as AutocompleteBuilder, t as AutocompleteResponse, s as AutocompleteSuggestion, y as BatchBuilder, B as BatchClient, z as BatchMethod, D as BatchOperation, G as BatchOperationResult, F as BatchOptions, J as BatchResponse, I as BatchSummary, j as ChildrenOptions, C as ClientSchema, b as ConditionalWriteOptions, ac as ConfirmInput, ad as ConfirmResult, i as ContentByIdBuilder, d as ContentClient, h as ContentQueryBuilder, ag as CreateAssetOptions, E as ExtendedQueryResult, a4 as FileBackend, am as FileErrorCode, a3 as FileStatus, an as FileUploadError, ap as FileValidationConstraints, ao as FileValidationError, U as FilterValue, V as FullTextConfig, H as HttpClient, ai as MultipartCreateResult, aj as MultipartPart, ak as MultipartTarget, a9 as PopulatedAssetReference, aa as PresignInput, ab as PresignResult, Y as QueryMetadata, ae as ResolveUrlInput, af as ResolveUrlResult, R as RetryableWriteOptions, n as SearchBuilder, m as SearchClient, x as SearchFields, w as SearchFilter, p as SearchMode, r as SearchResponse, q as SearchResultItem, S as SendOptions, g as SettingsClient, l as SettingsFetchOptions, o as SimilarBuilder, v as SimilarResponse, u as SimilarResult, f as SingletonClient, k as SingletonFetchOptions, a as TypedClientConfig, T as TypedRelyIOClient, al as UploadProgress, ah as WaitUntilReadyOptions, c as createClient, c as default, e as entityTagOf, a1 as isAssetEntry, aq as validateFile } from './index-B-KiFHbx.js';
+export { fields } from './schema/index.js';
+import { S as SDKError } from './index-BsUqCAu8.js';
+export { a as ApiMethod, A as ApiPath, r as ApiResponse, b as ApiSuccessBody, B as BaseContent, v as BaseValidationError, o as CacheConfig, t as CacheStrategy, f as ContentQueryResult, j as ContentTypeSchema, C as CreateInput, i as CustomQuery, D as DebugConfig, E as Environment, k as FieldOptions, F as FieldTypeName, z as InvalidFieldTypeError, I as InvalidPayloadError, L as LogLevel, P as PerformanceMetrics, Q as QueryOptions, p as RealtimeConfig, m as RealtimeEvent, l as RealtimeEventType, R as RelyIOConfig, q as RequestConfig, y as RequiredFieldError, s as RetryConfig, x as SchemaValidationError, h as SettingsGroup, g as SingletonContent, e as SortOptions, n as SubscriptionOptions, U as UpdateInput, w as ValidationError, V as ValidationRule, u as ValidationViolation, c as WhereClause, d as WhereOperator, W as Wire } from './index-BsUqCAu8.js';
+export { camelToSnake, createDeferred, debounce, deepClone, generateId, isBrowser, isNode, isPlainObject, isValidEmail, isValidUrl, mergeDeep, omit, pick, retry, sleep, snakeToCamel, throttle, toSafeString } from './utils/index.js';
+export { bv as AggregateBlock, ap as AssetTypeConfig, as as AssetTypeDefinition, n as BaseFieldConfig, ae as ComponentConfig, af as ComponentDefinition, ag as ComponentMetadata, a1 as ContentTypeConfig, a2 as ContentTypeConfigWithFields, a3 as ContentTypeConfigWithFieldsets, a4 as ContentTypeDefinition, a5 as EntryMetadata, bu as FetchBlock, c as FieldDefinition, b as FieldRule, o as FieldType, F as FieldUIConfig, a0 as Fieldset, aw as FileKindConfig, aK as FileScanConfig, aJ as FileUploadConfig, bF as FilterDefinition, aC as ImageExifConfig, au as ImageKindConfig, aB as ImageSourceConfig, aA as ImageUploadConfig, bD as IncludeDefinition, at as InferAssetType, a6 as InferContentType, bL as InferQueryParams, bK as InferQueryResponse, ac as InferSingleton, ab as InferSingletonContentType, L as LocalizationConfig, bs as QueryConfig, bt as QueryDefinition, K as SchemaAssetTypeNames, w as SchemaConfig, y as SchemaContentTypeNames, x as SchemaDefinition, H as SchemaLocaleCodes, G as SchemaQueryNames, J as SchemaSettingsGroupNames, z as SchemaSingletonNames, bw as SearchBlock, bE as SelectMapping, ak as SettingsGroupConfig, al as SettingsGroupDefinition, bx as SimilarBlock, a9 as SingletonContentTypeDefinition, aa as SingletonMetadata, bB as SortCondition, aD as VariantDefinition, aG as VideoCaptionsConfig, aH as VideoDownloadConfig, av as VideoKindConfig, aF as VideoPosterConfig, aE as VideoUploadConfig, aI as VideoWatermarkConfig, by as WhereCondition, ao as defineAssetType, ad as defineComponent, _ as defineContentType, br as defineQuery, u as defineSchema, aj as defineSettingsGroup, a8 as defineSingleton, a7 as defineSingletonContentType, $ as fieldset, v as schemaToJSON } from './define-schema-DHvUCKwj.js';
+
+/**
+ * Network-related errors
+ */
+declare class NetworkError extends SDKError {
+    readonly code = "NETWORK_ERROR";
+    readonly retryable = true;
+    constructor(message?: string, statusCode?: number, cause?: Error, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+declare class TimeoutError extends SDKError {
+    readonly code = "TIMEOUT_ERROR";
+    readonly retryable = true;
+    constructor(message?: string, timeout?: number, statusCode?: number, cause?: Error);
+    getUserMessage(): string;
+}
+declare class ConnectionError extends SDKError {
+    readonly code = "CONNECTION_ERROR";
+    readonly retryable = true;
+    constructor(message?: string, statusCode?: number, cause?: Error, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+
+/**
+ * Authentication and authorization errors.
+ *
+ * `ExpiredTokenError` was deleted at API5. The mapper reached it by sniffing an
+ * `EXPIRED_TOKEN` code, and no route in the closed vocabulary can send that
+ * name — so nothing could construct it and nothing could catch it
+ * (`INV-API-CODES-ARE-A-CLOSED-UNION`: a code no route declares is deleted, not
+ * retained). An API key that has expired arrives as `INVALID_API_KEY` with
+ * `details.reason: 'expired'`.
+ */
+declare class AuthenticationError extends SDKError {
+    readonly code = "AUTHENTICATION_ERROR";
+    readonly retryable = false;
+    constructor(message?: string, statusCode?: number, cause?: Error, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+declare class AuthorizationError extends SDKError {
+    readonly code = "AUTHORIZATION_ERROR";
+    readonly retryable = false;
+    constructor(message?: string, statusCode?: number, cause?: Error, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+declare class InvalidApiKeyError extends SDKError {
+    readonly code = "INVALID_API_KEY";
+    readonly retryable = false;
+    constructor(message?: string, cause?: Error, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+
+/**
+ * Content and resource errors.
+ *
+ * `ContentTypeNotFoundError` and `ContentNotFoundError` were deleted at API5.
+ * The mapper reached them by sniffing `CONTENT_TYPE_NOT_FOUND` and
+ * `CONTENT_NOT_FOUND`, neither of which is in the closed vocabulary, so neither
+ * class was reachable. Both cases are `RESOURCE_NOT_FOUND`, whose declared
+ * `details` are `{ kind, id? }` — the same two facts, from the one code a route
+ * can actually declare.
+ */
+declare class ResourceNotFoundError extends SDKError {
+    readonly code = "RESOURCE_NOT_FOUND";
+    readonly retryable = false;
+    constructor(message?: string, statusCode?: number, cause?: Error, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+declare class ResourceConflictError extends SDKError {
+    readonly code = "RESOURCE_CONFLICT";
+    readonly retryable = false;
+    constructor(message?: string, statusCode?: number, cause?: Error, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+declare class ResourceExpiredError extends SDKError {
+    readonly code = "RESOURCE_EXPIRED";
+    readonly retryable = false;
+    constructor(message?: string, statusCode?: number, cause?: Error, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+/**
+ * "Did the service say this resource does not exist?"
+ *
+ * Reads the **code**, not the status. Four contract codes are 4xx on a read and
+ * only one of them means "not there"; the incumbent checked `statusCode === 404`
+ * on the thrown value, and a second arm duck-typed a plain object for the same
+ * number so a hand-written test double would pass. Both are the branch
+ * `INV-API-CLIENT-IS-DERIVED` forbids where a code exists — and the second one
+ * only existed because the tests faked the boundary (rule 20). They now stub
+ * `fetch`, so the double is gone with the branch.
+ */
+declare function isResourceNotFound(error: unknown): boolean;
+
+/**
+ * One class per contract code that had none.
+ *
+ * The vocabulary's organising rule is Decision 3's: a code exists only if a
+ * client would **do something different** because of it. A mapper that folds
+ * `USAGE_QUOTA_EXCEEDED`, `READ_ONLY_KEY` and `PLAN_FEATURE_UNAVAILABLE` into
+ * one `AuthorizationError` throws that distinction away at the last step — the
+ * server took care to say which of the three it was, and the client that has to
+ * decide "retry later", "use a write key" or "upgrade the plan" cannot tell.
+ * Before this phase the mapper switched on the numeric **status**, so all three
+ * arrived as 403 and were literally indistinguishable.
+ *
+ * `retryable` is the field the retry loop reads, so it is a behavioural claim
+ * rather than a label: `RATE_LIMIT_EXCEEDED` and `SERVICE_INDETERMINATE` are
+ * the only refusals a later attempt can change, and `SERVICE_INDETERMINATE`
+ * only because `INV-AC-INDETERMINATE-IS-AN-OUTAGE` says it is an outage rather
+ * than a denial.
+ */
+/** `MISSING_API_KEY` — no `X-API-Key` header reached the service. */
+declare class MissingApiKeyError extends SDKError {
+    readonly code = "MISSING_API_KEY";
+    readonly retryable = false;
+    constructor(message?: string, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+/** `READ_ONLY_KEY` — the key is valid and cannot write. */
+declare class ReadOnlyKeyError extends SDKError {
+    readonly code = "READ_ONLY_KEY";
+    readonly retryable = false;
+    constructor(message?: string, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+/** `PLAN_FEATURE_UNAVAILABLE` — the plan does not include the capability. */
+declare class PlanFeatureUnavailableError extends SDKError {
+    readonly code = "PLAN_FEATURE_UNAVAILABLE";
+    readonly retryable = false;
+    /** The entitlement key the service named, when it named one. */
+    readonly feature?: string;
+    constructor(message?: string, feature?: string, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+/** `USAGE_QUOTA_EXCEEDED` — a metered allowance is spent for this cycle. */
+declare class UsageQuotaExceededError extends SDKError {
+    readonly code = "USAGE_QUOTA_EXCEEDED";
+    readonly retryable = false;
+    /** The meter the service named. Always present on a refusal from the contract. */
+    readonly meter?: string;
+    /** The threshold, where the deciding seam carried one — often it does not. */
+    readonly limit?: number;
+    constructor(message?: string, meter?: string, limit?: number, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+/**
+ * `RATE_LIMIT_EXCEEDED` — too many requests in the window.
+ *
+ * The one refusal the SDK's own retry loop acts on. `resetAt` and `limit` are
+ * optional because the IP window can fill neither honestly, which is the same
+ * decision the service made about its `X-RateLimit-*` headers at API0c.
+ */
+declare class RateLimitError extends SDKError {
+    readonly code = "RATE_LIMIT_EXCEEDED";
+    readonly retryable = true;
+    readonly limit?: number;
+    readonly resetAt?: string;
+    constructor(message?: string, limit?: number, resetAt?: string, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+/** `METHOD_NOT_ALLOWED` — the route exists and does not serve this verb. */
+declare class MethodNotAllowedError extends SDKError {
+    readonly code = "METHOD_NOT_ALLOWED";
+    readonly retryable = false;
+    constructor(message?: string, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+/** `PAYLOAD_TOO_LARGE` — the request body exceeded the declared ceiling. */
+declare class PayloadTooLargeError extends SDKError {
+    readonly code = "PAYLOAD_TOO_LARGE";
+    readonly retryable = false;
+    readonly limitBytes?: number;
+    constructor(message?: string, limitBytes?: number, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+/**
+ * `TRANSACTION_ROLLED_BACK` — an atomic batch failed at one member and nothing
+ * was written. `failedIndex` is which one, so a caller can fix that operation
+ * rather than re-sending the whole batch blind.
+ */
+declare class TransactionRolledBackError extends SDKError {
+    readonly code = "TRANSACTION_ROLLED_BACK";
+    readonly retryable = false;
+    readonly failedIndex?: number;
+    constructor(message?: string, failedIndex?: number, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+/**
+ * `SERVICE_INDETERMINATE` — a dependency the service needed to decide was
+ * unreachable, so it answered "I could not tell" rather than "no"
+ * (`INV-AC-INDETERMINATE-IS-AN-OUTAGE`). Retryable: it is an outage.
+ */
+declare class ServiceIndeterminateError extends SDKError {
+    readonly code = "SERVICE_INDETERMINATE";
+    readonly retryable = true;
+    readonly missing?: string;
+    constructor(message?: string, missing?: string, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+/** `INTERNAL_ERROR` — everything a client can only log (Decision 3). */
+declare class ServerError extends SDKError {
+    readonly code = "INTERNAL_ERROR";
+    readonly retryable = true;
+    constructor(message?: string, statusCode?: number, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+/**
+ * A refusal whose code this build of the SDK does not know.
+ *
+ * This is the arm the widened union forces a `default` for, and it is the
+ * normal case for a published client: the service can gain a code at any time
+ * and every SDK already installed is older than that. Carrying the code through
+ * as data is what keeps adding one additive — the alternative, a thrown parse
+ * failure, would turn a new server code into a client crash.
+ */
+declare class UnknownContractError extends SDKError {
+    readonly code: string;
+    readonly retryable = false;
+    constructor(code: string, message: string, statusCode: number, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+
+/**
+ * Map a RelyIO refusal onto an SDK error class.
+ *
+ * **It switches on `error.code`, not on the numeric status.** The status is a
+ * transport fact and it is lossy by design: five contract codes share 403 and
+ * two share 401, so a status-driven mapper cannot tell `MISSING_API_KEY` from
+ * `INVALID_API_KEY` — the client that would prompt for a key and the client
+ * that would rotate one got the same class. Switching on the code is what
+ * `INV-API-CLIENT-IS-DERIVED` means by "MUST NOT branch on the numeric status
+ * where a contract code exists".
+ *
+ * There is no `isApiErrorData` here any more. It accepted **any** object, so it
+ * asserted nothing, and every read past it was a guess. `readError` from the
+ * contract is the one parser: it returns the refusal or `undefined`, and
+ * `undefined` means the body was never a RelyIO refusal — a proxy page, a
+ * gateway timeout — which is reported as a transport failure rather than
+ * dressed up as one of the service's codes (rule 6).
+ *
+ * The `default` arm is not optional and is not defensive padding: the
+ * customer-facing union is widened with an unknown arm precisely so this switch
+ * cannot compile without it (Decision 13). A published SDK is always older than
+ * the service, so a code it has never heard of is the expected case and must
+ * reach the caller as data.
+ */
+declare class ErrorMapper {
+    /** Map a non-2xx response to an SDK error. */
+    static mapHttpError(response: {
+        status: number;
+        statusText: string;
+        body?: unknown;
+        headers?: Record<string, string>;
+    }, requestContext?: Record<string, unknown>): SDKError;
+    private static fromContractCode;
+    /**
+     * Map generic JavaScript errors to SDK errors
+     */
+    static mapGenericError(error: Error, _context?: Record<string, unknown>): SDKError;
+    /**
+     * Check if an error is retryable
+     */
+    static isRetryable(error: Error): boolean;
+    /**
+     * Extract retry delay from error
+     */
+    static getRetryDelay(_error: Error): number;
+}
+
+/**
+ * Locale utilities and helpers for the RelyIO SDK
+ *
+ * Provides convenient functions for working with localized content,
+ * building language switchers, and detecting translation status.
+ *
+ * @example
+ * ```typescript
+ * import { localeHelpers } from '@relyio/sdk'
+ *
+ * // Check if entry needs translation
+ * const needsWork = localeHelpers.needsTranslation(entry, 'de-DE')
+ *
+ * // Build language switcher options
+ * const options = localeHelpers.buildLanguageSwitcher(entry, {
+ *   currentLocale: 'en-US',
+ * })
+ * ```
+ */
+/**
+ * Locale status information from entry metadata
+ */
+interface LocaleStatus {
+    code: string;
+    status: 'published' | 'draft' | 'archived';
+    version?: number;
+    publishedAt?: string;
+}
+/**
+ * Entry metadata with locale information
+ */
+interface LocaleMetadata {
+    locale?: string;
+    requestedLocale?: string;
+    defaultLocale?: string;
+    localeFallbacksApplied?: Record<string, string>;
+    availableLocales?: LocaleStatus[];
+    localizations?: Record<string, unknown>;
+}
+/**
+ * Entry with locale metadata
+ */
+interface LocalizedEntry {
+    _metadata?: LocaleMetadata;
+    [key: string]: unknown;
+}
+/**
+ * Language switcher option
+ */
+interface LanguageSwitcherOption {
+    code: string;
+    label: string;
+    status: 'published' | 'draft' | 'archived';
+    isCurrent: boolean;
+    isDefault: boolean;
+    hasContent: boolean;
+}
+/**
+ * Options for building language switcher
+ */
+interface LanguageSwitcherOptions {
+    /** Current locale code */
+    currentLocale: string;
+    /** Whether to show inactive locales */
+    showInactive?: boolean;
+    /** Whether to show archived locales */
+    showArchived?: boolean;
+    /** Custom display name resolver */
+    getDisplayName?: (code: string) => string;
+}
+/**
+ * Translation completeness per locale
+ */
+interface TranslationCompleteness {
+    [localeCode: string]: number;
+}
+/**
+ * Check if an entry needs translation for a specific locale
+ *
+ * Returns true if any fields fell back to another locale
+ *
+ * @example
+ * ```typescript
+ * const product = await client.content('product')
+ *   .findById('prod_123')
+ *   .locale('de-DE')
+ *   .execute()
+ *
+ * if (localeHelpers.needsTranslation(product)) {
+ *   showTranslationBadge()
+ * }
+ * ```
+ */
+declare function needsTranslation(entry: LocalizedEntry, locale?: string): boolean;
+/**
+ * Get the fields that are using fallback content
+ *
+ * @example
+ * ```typescript
+ * const fallbackFields = localeHelpers.getFallbackFields(product)
+ * // Returns: { description: 'en-US', excerpt: 'en-US' }
+ * ```
+ */
+declare function getFallbackFields(entry: LocalizedEntry): Record<string, string>;
+/**
+ * Check if a specific field is using fallback content
+ */
+declare function isFieldFallback(entry: LocalizedEntry, fieldName: string): boolean;
+/**
+ * Get the fallback locale for a specific field
+ */
+declare function getFieldFallbackLocale(entry: LocalizedEntry, fieldName: string): string | null;
+/**
+ * Build language switcher options from an entry
+ *
+ * @example
+ * ```typescript
+ * const options = localeHelpers.buildLanguageSwitcher(product, {
+ *   currentLocale: 'en-US',
+ *   showArchived: false,
+ * })
+ *
+ * // Returns:
+ * // [
+ * //   { code: 'en-US', label: 'English (US)', status: 'published', isCurrent: true, isDefault: true, hasContent: true },
+ * //   { code: 'es-ES', label: 'es-ES', status: 'published', isCurrent: false, isDefault: false, hasContent: true },
+ * // ]
+ * ```
+ */
+declare function buildLanguageSwitcher(entry: LocalizedEntry, options: LanguageSwitcherOptions): LanguageSwitcherOption[];
+/**
+ * Get available locale codes from an entry
+ */
+declare function getAvailableLocaleCodes(entry: LocalizedEntry): string[];
+/**
+ * Get published locale codes from an entry
+ */
+declare function getPublishedLocaleCodes(entry: LocalizedEntry): string[];
+/**
+ * Check if an entry has content in a specific locale
+ */
+declare function hasLocale(entry: LocalizedEntry, localeCode: string): boolean;
+/**
+ * Check if an entry is published in a specific locale
+ */
+declare function isPublishedInLocale(entry: LocalizedEntry, localeCode: string): boolean;
+/**
+ * Get the default locale from entry metadata
+ */
+declare function getDefaultLocale(entry: LocalizedEntry): string | null;
+/**
+ * Get the requested locale from entry metadata
+ */
+declare function getRequestedLocale(entry: LocalizedEntry): string | null;
+/**
+ * Calculate translation completeness percentage for each locale
+ *
+ * This is an estimate based on available locale information.
+ * For accurate completeness, you should track field-level translations.
+ *
+ * @example
+ * ```typescript
+ * const completeness = localeHelpers.estimateTranslationCompleteness(entry, ['title', 'description', 'excerpt'])
+ * // Returns: { 'en-US': 100, 'es-ES': 66, 'de-DE': 33 }
+ * ```
+ */
+declare function estimateTranslationCompleteness(entry: LocalizedEntry, localizedFieldNames: string[]): TranslationCompleteness;
+/**
+ * Get localized content from entry's localizations
+ *
+ * @example
+ * ```typescript
+ * const entry = await client.content('product')
+ *   .findById('prod_123')
+ *   .allLocales()
+ *   .execute()
+ *
+ * const spanishTitle = localeHelpers.getLocalizedField(entry, 'title', 'es-ES')
+ * ```
+ */
+declare function getLocalizedField<T = unknown>(entry: LocalizedEntry, fieldName: string, localeCode: string): T | null;
+/**
+ * Get all localized values for a field
+ *
+ * @example
+ * ```typescript
+ * const titles = localeHelpers.getAllLocalizedValues(entry, 'title')
+ * // Returns: { 'en-US': 'Product', 'es-ES': 'Producto', 'de-DE': 'Produkt' }
+ * ```
+ */
+declare function getAllLocalizedValues(entry: LocalizedEntry, fieldName: string): Record<string, unknown>;
+/**
+ * Locale helpers namespace for convenient access
+ */
+declare const localeHelpers: {
+    needsTranslation: typeof needsTranslation;
+    getFallbackFields: typeof getFallbackFields;
+    isFieldFallback: typeof isFieldFallback;
+    getFieldFallbackLocale: typeof getFieldFallbackLocale;
+    buildLanguageSwitcher: typeof buildLanguageSwitcher;
+    getAvailableLocaleCodes: typeof getAvailableLocaleCodes;
+    getPublishedLocaleCodes: typeof getPublishedLocaleCodes;
+    hasLocale: typeof hasLocale;
+    isPublishedInLocale: typeof isPublishedInLocale;
+    getDefaultLocale: typeof getDefaultLocale;
+    getRequestedLocale: typeof getRequestedLocale;
+    estimateTranslationCompleteness: typeof estimateTranslationCompleteness;
+    getLocalizedField: typeof getLocalizedField;
+    getAllLocalizedValues: typeof getAllLocalizedValues;
+};
+
+/**
+ * RelyIO SDK - Main Entry Point
+ *
+ * @example With schema (fully typed, recommended)
+ * ```typescript
+ * import { createClient, defineSchema, defineContentType, fields } from '@relyio/sdk'
+ *
+ * const product = defineContentType('product', {
+ *   displayName: 'Product',
+ *   fields: [
+ *     fields.shortText('title', { config: { required: true } }),
+ *     fields.decimal('price', { config: { min: 0, decimalPlaces: 2 } }),
+ *   ]
+ * })
+ *
+ * const schema = defineSchema({ contentTypes: { product } })
+ * const client = createClient({ apiKey: '...', schema })
+ *
+ * // Full autocomplete for content types and fields!
+ * const products = await client.content('product').query().execute()
+ * ```
+ *
+ * @example Without schema (dynamic usage)
+ * ```typescript
+ * import { createClient } from '@relyio/sdk'
+ *
+ * const client = createClient({ apiKey: '...' })
+ *
+ * // Works dynamically without type checking
+ * const products = await client.content('product').query().execute()
+ * const results = await client.search('wireless').in('product').execute()
+ * ```
+ */
+
+declare const VERSION = "__VERSION__";
+
+export { AuthenticationError, AuthorizationError, ConnectionError, ErrorMapper, InvalidApiKeyError, type LanguageSwitcherOption, type LanguageSwitcherOptions, type LocaleMetadata, type LocaleStatus, type LocalizedEntry, MethodNotAllowedError, MissingApiKeyError, NetworkError, PayloadTooLargeError, PlanFeatureUnavailableError, RateLimitError, ReadOnlyKeyError, ResourceConflictError, ResourceExpiredError, ResourceNotFoundError, SDKError, ServerError, ServiceIndeterminateError, TimeoutError, TransactionRolledBackError, type TranslationCompleteness, UnknownContractError, UsageQuotaExceededError, VERSION, buildLanguageSwitcher, estimateTranslationCompleteness, getAllLocalizedValues, getAvailableLocaleCodes, getDefaultLocale, getFallbackFields, getFieldFallbackLocale, getLocalizedField, getPublishedLocaleCodes, getRequestedLocale, hasLocale, isFieldFallback, isPublishedInLocale, isResourceNotFound, localeHelpers, needsTranslation };

package/dist/index.js

@@ -0,0 +1,148 @@
+export { defineAssetType, defineComponent, defineContentType, defineQuery, defineSchema, defineSettingsGroup, defineSingleton, defineSingletonContentType, fields, fieldset, schemaToJSON } from './chunk-2QUK2ZGD.js';
+export { AdhocQueryBuilder, AdhocQueryClient, AssetClient, AssetFileBuilder, AssetUploadBuilder, AuthenticationError, AuthorizationError, AutocompleteBuilder, BaseValidationError, BatchBuilder, BatchClient, ConnectionError, ContentByIdBuilder, ContentClient, ContentQueryBuilder, ErrorMapper, FileUploadError, FileValidationError, HttpClient, InvalidApiKeyError, InvalidFieldTypeError, InvalidPayloadError, MethodNotAllowedError, MissingApiKeyError, NetworkError, PayloadTooLargeError, PlanFeatureUnavailableError, RateLimitError, ReadOnlyKeyError, RequiredFieldError, ResourceConflictError, ResourceExpiredError, ResourceNotFoundError, SDKError, SchemaValidationError, SearchBuilder, SearchClient, ServerError, ServiceIndeterminateError, SettingsClient, SimilarBuilder, SingletonClient, TimeoutError, TransactionRolledBackError, TypedRelyIOClient, UnknownContractError, UsageQuotaExceededError, ValidationError, createClient, createClient as default, entityTagOf, isAssetEntry, isResourceNotFound, validateFile } from './chunk-RJBIJ2ZK.js';
+import './chunk-IY5LSKXU.js';
+export { camelToSnake, createDeferred, debounce, deepClone, generateId, isBrowser, isNode, isPlainObject, isValidEmail, isValidUrl, mergeDeep, omit, pick, retry, sleep, snakeToCamel, throttle, toSafeString } from './chunk-I3ESNANB.js';
+import { __name } from './chunk-XQ4QHWZE.js';
+
+/* RelyIO SDK - Built with ❤️ by the RelyIO Team */
+
+// src/locale/index.ts
+function needsTranslation(entry, locale) {
+  const fallbacks = entry._metadata?.localeFallbacksApplied;
+  if (!fallbacks) return false;
+  if (locale !== void 0 && locale !== "" && entry._metadata?.requestedLocale !== locale) {
+    return false;
+  }
+  return Object.keys(fallbacks).length > 0;
+}
+__name(needsTranslation, "needsTranslation");
+function getFallbackFields(entry) {
+  return entry._metadata?.localeFallbacksApplied ?? {};
+}
+__name(getFallbackFields, "getFallbackFields");
+function isFieldFallback(entry, fieldName) {
+  const fallbacks = entry._metadata?.localeFallbacksApplied;
+  return fallbacks ? fieldName in fallbacks : false;
+}
+__name(isFieldFallback, "isFieldFallback");
+function getFieldFallbackLocale(entry, fieldName) {
+  const fallbacks = entry._metadata?.localeFallbacksApplied;
+  return fallbacks?.[fieldName] ?? null;
+}
+__name(getFieldFallbackLocale, "getFieldFallbackLocale");
+function buildLanguageSwitcher(entry, options) {
+  const availableLocales = entry._metadata?.availableLocales ?? [];
+  const defaultLocale = entry._metadata?.defaultLocale;
+  return availableLocales.filter((locale) => {
+    if (options.showArchived !== true && locale.status === "archived") {
+      return false;
+    }
+    return true;
+  }).map((locale) => ({
+    code: locale.code,
+    label: options.getDisplayName?.(locale.code) ?? locale.code,
+    status: locale.status,
+    isCurrent: locale.code === options.currentLocale,
+    isDefault: locale.code === defaultLocale,
+    hasContent: locale.status !== "archived"
+  }));
+}
+__name(buildLanguageSwitcher, "buildLanguageSwitcher");
+function getAvailableLocaleCodes(entry) {
+  return entry._metadata?.availableLocales?.map((l) => l.code) ?? [];
+}
+__name(getAvailableLocaleCodes, "getAvailableLocaleCodes");
+var LOCALE_STATUS_PUBLISHED = "published";
+function getPublishedLocaleCodes(entry) {
+  return entry._metadata?.availableLocales?.filter((l) => l.status === LOCALE_STATUS_PUBLISHED).map((l) => l.code) ?? [];
+}
+__name(getPublishedLocaleCodes, "getPublishedLocaleCodes");
+function hasLocale(entry, localeCode) {
+  return entry._metadata?.availableLocales?.some((l) => l.code === localeCode) ?? false;
+}
+__name(hasLocale, "hasLocale");
+function isPublishedInLocale(entry, localeCode) {
+  return entry._metadata?.availableLocales?.some(
+    (l) => l.code === localeCode && l.status === LOCALE_STATUS_PUBLISHED
+  ) ?? false;
+}
+__name(isPublishedInLocale, "isPublishedInLocale");
+function getDefaultLocale(entry) {
+  return entry._metadata?.defaultLocale ?? null;
+}
+__name(getDefaultLocale, "getDefaultLocale");
+function getRequestedLocale(entry) {
+  return entry._metadata?.requestedLocale ?? null;
+}
+__name(getRequestedLocale, "getRequestedLocale");
+function estimateTranslationCompleteness(entry, localizedFieldNames) {
+  const result = {};
+  const availableLocales = entry._metadata?.availableLocales ?? [];
+  const fallbacks = entry._metadata?.localeFallbacksApplied ?? {};
+  const requestedLocale = entry._metadata?.requestedLocale;
+  const defaultLocale = entry._metadata?.defaultLocale;
+  if (defaultLocale !== void 0 && defaultLocale !== "") {
+    result[defaultLocale] = 100;
+  }
+  if (requestedLocale !== void 0 && requestedLocale !== "" && requestedLocale !== defaultLocale) {
+    const fallbackCount = Object.keys(fallbacks).filter((f) => localizedFieldNames.includes(f)).length;
+    const totalFields = localizedFieldNames.length;
+    const translatedFields = totalFields - fallbackCount;
+    result[requestedLocale] = totalFields > 0 ? Math.round(translatedFields / totalFields * 100) : 100;
+  }
+  for (const locale of availableLocales) {
+    if (!(locale.code in result)) {
+      result[locale.code] = locale.status === LOCALE_STATUS_PUBLISHED ? 50 : 0;
+    }
+  }
+  return result;
+}
+__name(estimateTranslationCompleteness, "estimateTranslationCompleteness");
+function getLocalizedField(entry, fieldName, localeCode) {
+  const localizations = entry._metadata?.localizations;
+  if (!localizations) return null;
+  const localeContent = localizations[localeCode];
+  return localeContent?.[fieldName] ?? null;
+}
+__name(getLocalizedField, "getLocalizedField");
+function getAllLocalizedValues(entry, fieldName) {
+  const result = {};
+  const defaultLocale = entry._metadata?.defaultLocale;
+  if (defaultLocale !== void 0 && defaultLocale !== "" && fieldName in entry) {
+    result[defaultLocale] = entry[fieldName];
+  }
+  const localizations = entry._metadata?.localizations;
+  if (localizations) {
+    for (const [localeCode, content] of Object.entries(localizations)) {
+      const localeContent = content;
+      if (fieldName in localeContent) {
+        result[localeCode] = localeContent[fieldName];
+      }
+    }
+  }
+  return result;
+}
+__name(getAllLocalizedValues, "getAllLocalizedValues");
+var localeHelpers = {
+  needsTranslation,
+  getFallbackFields,
+  isFieldFallback,
+  getFieldFallbackLocale,
+  buildLanguageSwitcher,
+  getAvailableLocaleCodes,
+  getPublishedLocaleCodes,
+  hasLocale,
+  isPublishedInLocale,
+  getDefaultLocale,
+  getRequestedLocale,
+  estimateTranslationCompleteness,
+  getLocalizedField,
+  getAllLocalizedValues
+};
+
+// src/index.ts
+var VERSION = "__VERSION__";
+
+export { VERSION, buildLanguageSwitcher, estimateTranslationCompleteness, getAllLocalizedValues, getAvailableLocaleCodes, getDefaultLocale, getFallbackFields, getFieldFallbackLocale, getLocalizedField, getPublishedLocaleCodes, getRequestedLocale, hasLocale, isFieldFallback, isPublishedInLocale, localeHelpers, needsTranslation };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/react/index.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/react/index.d.cts

@@ -0,0 +1,2 @@
+
+export {  }