@xano/sdk 1.0.0

package/dist/internal.d.ts

@@ -0,0 +1,179 @@
+export { a4 as FIELD_METHODS, a5 as REFERENCEABLE_KINDS, a6 as deriveGuid, a7 as encodeResponse, a8 as encodeStatement, a9 as getStatementFactory, aa as isRegisteredStatement, ab as resolveRef, ac as toNestedFields } from './response-HlXahv4K.js';
+import { q as StatementSpec } from './store-DuYfzKlW.js';
+export { P as FILTER_NAMES, Q as GENERATED_STATEMENT_NAMES, T as LLMS_TXT, M as Manifest, m as ManifestField, n as ManifestKind, o as ManifestStatement, U as TOTAL_OBJECT_KINDS, V as buildManifest, W as encodeFromSpec, X as generatedStatements, Y as getLockedCanonical, Z as getLockedGuid, _ as isLockSeeded, $ as registerSpec, a0 as renderDocs, a1 as renderLlmsTxt } from './store-DuYfzKlW.js';
+import { F as FunctionDef, aL as ObjectKind } from './emit-CyhBDxli.js';
+export { b as AdoptChange, c as AdoptResult, B as Bundle, p as BundlePayload, q as BundleType, cJ as KNOWLEDGE_DIR, cK as KNOWLEDGE_FILE, cL as LOCK_PAYLOAD_KEYS, cM as LOCK_VERSION, ae as LockEntry, af as LockExportContext, L as LockFile, av as MergeResult, cN as PAYLOAD_ARRAY_KEYS, aR as PayloadArrayKey, cO as QUERY_EXPRESSION_FILTERS, bg as RenameResult, cP as VECTOR_FILTERS, cQ as WORKSPACE_KEY, cR as addonKind, cS as adoptFromBundle, cT as agentKind, cU as apiGroupKind, cV as buildBundle, cW as buildMiddlewareBlock, cX as buildWorkspaceHistory, cY as calcSignatureJson, cZ as channelPathParams, c_ as createLockContext, c$ as declaredServicePorts, d0 as emptyLock, d1 as encodeAddon, d2 as encodeAgent, d3 as encodeApiGroup, d4 as encodeColumn, d5 as encodeContainerHistory, d6 as encodeHistory, d7 as encodeIndex, d8 as encodeKnowledge, d9 as encodeMcpServer, da as encodeMicroservice, db as encodeMiddleware, dc as encodeMiddlewareEntry, dd as encodeMiddlewareList, de as encodeObject, df as encodeQuery, dg as encodeRealtimeChannel, dh as encodeRealtimeMessage, di as encodeRealtimeServer, dj as encodeSchedule, dk as encodeTable, dl as encodeTask, dm as encodeTool, dn as encodeToolRefs, dp as encodeToolsetBase, dq as encodeTrigger, dr as encodeView, ds as encodeWorkflowTest, dt as encodeWorkspaceConfig, du as getKind, dv as isKnowledgeDirSource, dw as isKnowledgeFileSource, dx as isQueryExpressionFilter, dy as isRegisteredKind, dz as knowledgeKind, dA as lockKey, dB as mcpServerKind, dC as mergeObserved, dD as microserviceKind, dE as middlewareKind, dF as mintCanonical, dG as parseLock, dH as phpJsonEncode, dI as queryKind, dJ as realtimeChannelGuid, dK as realtimeChannelKind, dL as realtimeMessageGuid, dM as realtimeMessageKind, dN as realtimeServerKind, dO as recordObserved, dP as registerKind, dQ as registeredKinds, dR as renameLockEntry, dS as resolveAuthRef, dT as resolvePayloadKey, dU as resolveRealtimeServerCanonical, dV as resolveToolsetCanonical, dW as serializeBundle, dX as serializeLock, dY as tableKind, dZ as taskKind, d_ as toolKind, d$ as triggerKind, e0 as validateLockModel, e1 as workflowTestKind, e2 as workspaceKind } from './emit-CyhBDxli.js';
+import { k as FunctionXdo } from './xdo-CxDr2Q1C.js';
+
+/**
+ * The declarative statement catalog: one StatementSpec per cleanly
+ * interpretable statement schema, generated from the Xano engine's statement
+ * schema definitions. The engine-only `output` flag is pinned from the
+ * persisted golden fixtures.
+ */
+
+declare const GENERATED_SPECS: StatementSpec[];
+
+/** One instance capability a bundle can depend on. */
+interface Capability {
+    /** What to look for on the instance, in the platform's own words. */
+    readonly label: string;
+    /** What stops working without it. */
+    readonly effect: string;
+}
+/**
+ * The capabilities the editor gates on, keyed as this SDK reports them.
+ *
+ * `paidInstance` is the one that is not a flag: the zip family is gated on the
+ * instance NOT being free, so it is stated positively here rather than as a
+ * negated flag an author would have to invert while reading.
+ */
+declare const CAPABILITIES: {
+    readonly cache: {
+        readonly label: "Redis / cache support";
+        readonly effect: "every `s.redis.*` statement, including `s.redis.ratelimit`";
+    };
+    readonly lambda: {
+        readonly label: "Lambda (JavaScript/TypeScript) support";
+        readonly effect: "`s.lambda`, and the `fl.lambda`-family filters that run through it";
+    };
+    readonly premiumInstance: {
+        readonly label: "a premium instance";
+        readonly effect: "`s.await` (awaiting an async function run) and direct SQL";
+    };
+    readonly directQuery: {
+        readonly label: "direct-query support";
+        readonly effect: "`s.db.direct_query` — raw SQL against this workspace's own tables";
+    };
+    readonly microservice: {
+        readonly label: "microservice support";
+        readonly effect: "`s.microservice.request`";
+    };
+    readonly realtimeV2: {
+        readonly label: "realtime (v2) support";
+        readonly effect: "`s.realtime.publish`";
+    };
+    readonly rawFileAccess: {
+        readonly label: "raw file access";
+        readonly effect: "reading a file resource's bytes, and the CSV/JSONL streaming readers";
+    };
+    readonly paidInstance: {
+        readonly label: "a paid (non-free) instance";
+        readonly effect: "the whole `s.zip.*` family";
+    };
+    readonly fileUpload: {
+        readonly label: "file upload";
+        readonly effect: "creating and deleting stored file resources";
+    };
+    readonly images: {
+        readonly label: "image storage";
+        readonly effect: "`s.storage.create_image`";
+    };
+    readonly videos: {
+        readonly label: "video storage";
+        readonly effect: "`s.storage.create_video`";
+    };
+    readonly audio: {
+        readonly label: "audio storage";
+        readonly effect: "`s.storage.create_audio`";
+    };
+    readonly attachment: {
+        readonly label: "attachment storage";
+        readonly effect: "`s.storage.create_attachment`";
+    };
+    readonly privateStorage: {
+        readonly label: "private file storage";
+        readonly effect: "`s.storage.sign_private_url`";
+    };
+    readonly webflow: {
+        readonly label: "the Webflow integration";
+        readonly effect: "`s.webflow.request`";
+    };
+    readonly datadog: {
+        readonly label: "the Datadog integration";
+        readonly effect: "every `s.datadog.*` statement";
+    };
+};
+/** A key of {@link CAPABILITIES}. */
+type CapabilityId = keyof typeof CAPABILITIES;
+/**
+ * Stored statement name → the capabilities its instance must have.
+ *
+ * `mvp:dbo_direct_query` carries two because the editor's predicate is a
+ * conjunction: a premium instance AND direct-query support. Everything else is
+ * one.
+ */
+declare const STATEMENT_CAPABILITIES: Readonly<Record<string, readonly CapabilityId[]>>;
+/** One capability a bundle needs, with what asked for it. */
+interface CapabilityRequirement {
+    readonly id: CapabilityId;
+    readonly label: string;
+    readonly effect: string;
+    /** The stored statement names in this bundle that need it, sorted. */
+    readonly statements: readonly string[];
+    /** The objects those statements sit in (nearest named ancestor), sorted. */
+    readonly objects: readonly string[];
+}
+/**
+ * Every instance capability a compiled bundle depends on.
+ *
+ * Walks the bundle for statement names rather than re-encoding the defs, so it
+ * sees exactly what will be deployed — including anything a `raw()` escape hatch
+ * put there, which a def-level walk would miss.
+ */
+declare function bundleCapabilities(bundle: unknown): CapabilityRequirement[];
+
+/**
+ * The canonical statement authoring-surface catalog — one entry per engine
+ * statement schema, mapping the surface key to its stored `mvp:` name. This is
+ * SDK metadata (it drives the agent-grounding manifest and the coverage report),
+ * so it lives in `src` rather than the test tree.
+ *
+ * A key normally mirrors the engine's own statement-schema filename, which
+ * keeps this catalog checkable against the engine one line at a time. One entry
+ * deliberately does not: `microservice.request` is stored as
+ * `mvp:microservice_request` and the engine files its schema under the `api`
+ * namespace, but a microservice is a first-class workspace object here — with
+ * its own def factory and deploy path — so its call statement is filed beside
+ * it. The same decision is mirrored in codegen, which is what keeps the
+ * generated factory tree in agreement with this key.
+ *
+ * A second entry does the same: `lambda` is stored as `mvp:lambda` and the
+ * engine files its schema under the `api` namespace, but a lambda runs wherever
+ * a stack runs — in functions, tasks, middleware, and triggers, not only APIs —
+ * so filing it under `s.api.*` said something false about where it is available.
+ * It is `s.lambda`, with the matching `NAMESPACE_OVERRIDES` entry.
+ *
+ * One surface-pair shares a stored name (so the catalog has one fewer unique
+ * stored name than surfaces): `util.get_raw_input`/`util.get_input` →
+ * `mvp:get_input`.
+ *
+ * `raw()` (from `@xano/sdk/codegen`) is deliberately **not** in this catalog
+ * and not under `s.`: it is a verbatim passthrough for stored statements the
+ * catalog cannot model, emitted by codegen, not authored by hand.
+ */
+/** Every engine statement schema file → its stored `mvp:` name. */
+declare const STATEMENT_SURFACES: ReadonlyArray<readonly [string, string]>;
+/** Total authoring surfaces (= engine statement schema file count). */
+declare const TOTAL_STATEMENTS: number;
+/** Statement authoring surfaces (by schema key). */
+declare const IMPLEMENTED_STATEMENTS: string[];
+/**
+ * The dotted `s.` authoring path for a surface key — e.g. `array.filter` →
+ * `array.filter` (reachable as `s.array.filter`), `stack|expect.to_equal` →
+ * `expect.to_equal`, `var` → `set_var`. Verified against the live `s` tree by
+ * the manifest test.
+ */
+declare function sPathOf(surfaceKey: string): string;
+
+/**
+ * The `function` object kind. This is the MVP's `compile()` envelope
+ * logic, re-homed as the first registered kind. Behavior is unchanged — the
+ * MVP golden test is the regression guard.
+ */
+
+/** Encode a `FunctionDef` into the flattened importable function `xdo`. */
+declare function encodeFunction(fn: FunctionDef): FunctionXdo;
+declare const functionKind: ObjectKind<FunctionDef, FunctionXdo>;
+
+export { CAPABILITIES, type Capability, type CapabilityId, type CapabilityRequirement, GENERATED_SPECS, IMPLEMENTED_STATEMENTS, ObjectKind, STATEMENT_CAPABILITIES, STATEMENT_SURFACES, TOTAL_STATEMENTS, bundleCapabilities, encodeFunction, functionKind, sPathOf };