@gscdump/engine 0.33.9 → 0.35.1

package/dist/_chunks/libs/icebird.d.mts

@@ -282,39 +282,6 @@ type ManifestList = {
   url: string;
   entries: ManifestEntry[];
 }[];
-/**
- * Append rows to a table in one call: load metadata, stage the parquet writes
- * + manifest + new snapshot, commit through the catalog.
- *
- * @param {object} options
- * @param {Catalog} options.catalog
- * @param {string | string[]} [options.namespace] - REST catalog only.
- * @param {string} [options.table] - REST catalog only.
- * @param {string} [options.tableUrl] - File catalog only.
- * @param {Resolver} [options.resolver]
- * @param {Record<string, any>[]} options.records
- * @param {number} [options.sortOrderId] - Sort order id to apply; defaults to the table default.
- * @returns {Promise<TableMetadata>}
- */
-declare function icebergAppend({
-  catalog,
-  namespace,
-  table,
-  tableUrl,
-  resolver,
-  records,
-  sortOrderId,
-  snapshotProperties
-}: {
-  catalog: Catalog;
-  namespace?: string | string[] | undefined;
-  table?: string | undefined;
-  tableUrl?: string | undefined;
-  resolver?: Resolver | undefined;
-  records: Record<string, any>[];
-  sortOrderId?: number | undefined;
-  snapshotProperties?: Record<string, string> | undefined;
-}): Promise<TableMetadata>;
 /**
  * Create a new table. REST: delegates to the catalog's create endpoint.
  * File: writes the initial `v1.metadata.json` and `version-hint.text` under
@@ -356,36 +323,6 @@ declare function icebergCreateTable({
   formatVersion?: 2 | 3 | undefined;
   stageCreate?: boolean | undefined;
 }): Promise<TableMetadata>;
-/**
- * Iceberg REST Catalog client.
- *
- * Plain async functions over a stateless context object — no classes.
- * The catalog client never imports from the read path; callers glue the
- * two together by passing `metadata` and `metadata.location` from
- * `restCatalogLoadTable` into `icebergRead`.
- *
- * @import {LoadTableResponse, PartitionSpec, RestCatalogContext, Schema, SortOrder, StorageCredential, TableIdentifier, TableMetadata, TableRequirement, TableUpdate} from '../../src/types.js'
- */
-/**
- * Connect to a REST catalog by fetching `/v1/config`.
- * Returns a frozen context object that holds the prefix, defaults, overrides
- * and the user-supplied requestInit (for auth) for use in subsequent calls.
- *
- * @param {object} options
- * @param {string} options.url - catalog base URL, with or without trailing slash
- * @param {string} [options.warehouse] - optional warehouse query param sent to /v1/config
- * @param {RequestInit} [options.requestInit] - fetch options (e.g. Authorization header)
- * @returns {Promise<RestCatalogContext>}
- */
-declare function restCatalogConnect({
-  url,
-  warehouse,
-  requestInit
-}: {
-  url: string;
-  warehouse?: string | undefined;
-  requestInit?: RequestInit | undefined;
-}): Promise<RestCatalogContext>;
 /**
  * Load a single table. Returns the inline TableMetadata, the metadata
  * file location, and any per-table config the server returned.
@@ -406,38 +343,4 @@ declare function restCatalogLoadTable(ctx: RestCatalogContext, {
   namespace: string | string[];
   table: string;
 }): Promise<LoadTableResponse>;
-/**
- * Wrap a `Resolver` so reads of the same path share one HTTP fetch and
- * subsequent range reads share one in-memory buffer. Writes and deletes
- * through the same resolver invalidate the cache entry for their path on
- * success, so a commit pipeline (`icebergAppend` → reload metadata) sees the
- * new bytes without manual invalidation.
- *
- * - `reader(path)` is memoized by path. The returned buffer is passed through
- *   `cachedAsyncBuffer` so range reads within a single file are also deduped.
- *   `byteLength` is a fetch hint and not part of the cache key — the bytes
- *   are the same either way.
- * - `writer(path).finish()` invalidates the cache entry only when the
- *   underlying finish resolves; a rejected finish (e.g. an `If-None-Match: *`
- *   collision returning 412/409) leaves the cached bytes intact, since the
- *   server-side object hasn't changed.
- * - `deleter(path)` invalidates the cache entry on success.
- * - `writer` and `deleter` are omitted when the base resolver omits them, so
- *   wrapping a read-only resolver still yields a read-only resolver.
- *
- * Iceberg writes are almost entirely create-new-path (data parquets, manifest
- * avros, snapshot avros, vN.metadata.json all live at fresh paths per
- * commit). Only `version-hint.text` and equivalent catalog-pointer files are
- * truly mutated in place, so path-level invalidation is sufficient to keep
- * single-process write-then-read pipelines consistent.
- *
- * Cross-process freshness is out of scope: a reader in process B does not
- * see writes committed by process A through a different cache. Use a
- * short-lived resolver, an external coordination layer, or wrap with TTL /
- * conditional-GET revalidation if you need that.
- *
- * @param {Resolver} base
- * @returns {Resolver}
- */
-declare function cachingResolver(base: Resolver): Resolver;
-export { cachingResolver, icebergAppend, icebergCreateTable, icebergManifests, restCatalogConnect, restCatalogLoadTable };
+export { icebergCreateTable, icebergManifests, restCatalogLoadTable };