@atlanai/sdk 0.2.1 → 0.2.2

package/dist/tracing/client.d.ts

@@ -77,6 +77,8 @@ export declare class AtlanAI {
      * acquired from it flow through the Atlan pipeline (allowlist + enrichment). */
     get tracerProvider(): BasicTracerProvider | null;
     getTracer(): Tracer;
+    /** Return the active OTel span through the Atlan ergonomic span surface. */
+    currentSpan(): AtlanSpan;
     /**
      * Create or refresh a Visitor and return its canonical artifact identity.
      * This never changes process-global identity; carry visitor.id through

package/dist/tracing/client.js

@@ -254,6 +254,13 @@ class AtlanAI {
         const provider = this.provider ?? api_1.trace.getTracerProvider();
         return provider.getTracer(span_filter_js_1.ATLAN_SDK_SCOPE, version_js_1.SDK_VERSION);
     }
+    /** Return the active OTel span through the Atlan ergonomic span surface. */
+    currentSpan() {
+        const active = api_1.trace.getSpan(api_1.context.active());
+        if (active === undefined)
+            return (0, spans_js_1.noopSpan)(this.config);
+        return new spans_js_1.AtlanSpan(active, this.config, this.mask, this.getTracer());
+    }
     /**
      * Create or refresh a Visitor and return its canonical artifact identity.
      * This never changes process-global identity; carry visitor.id through

package/dist/tracing/compat.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Low-friction tracing compatibility helpers.
+ *
+ * The implementation deliberately reuses the SDK's OTel pipeline: ended spans
+ * enter its bounded background batcher, `flush()` drains that same queue, and
+ * third-party OTel instrumentation shares the same provider. There is no
+ * second transport or vendor-specific event format to keep in sync.
+ */
+import { type AtlanAI, type InitOptions, type StartSpanOptions } from "./client.js";
+import { type ObserveOptions } from "./observe.js";
+import type { AtlanSpan, UpdateFields } from "./spans.js";
+type AnyFunction = (...args: any[]) => any;
+export interface InitLoggerOptions extends Omit<InitOptions, "exportMode" | "serviceName"> {
+    /** Braintrust migration alias. In Atlan this becomes the trace service name. */
+    projectName?: string;
+    /** Used as the service name when `projectName` is absent. */
+    projectId?: string;
+    /** Native Atlan spelling; takes precedence over the migration aliases. */
+    serviceName?: string;
+    /** Background batching is on by default. `false` switches to immediate export. */
+    asyncFlush?: boolean;
+    /** Export every OTel span. Defaults to true for logger-style observability. */
+    captureAll?: boolean;
+    /** Set this logger as the process current logger. Defaults to true. */
+    setCurrent?: boolean;
+}
+export interface StartSpanArgs extends StartSpanOptions {
+    name?: string;
+    type?: string;
+    event?: UpdateFields;
+}
+export interface LogEvent extends UpdateFields {
+    name?: string;
+    type?: string;
+}
+export interface LoggedSpan {
+    traceId: string;
+    spanId: string;
+}
+export interface WrapTracedOptions extends Omit<ObserveOptions, "asType"> {
+    type?: string;
+    asType?: string;
+    /** Suppress automatic argument and return-value capture. */
+    noTraceIO?: boolean;
+}
+/** A small logger facade over one Atlan OTel client. */
+export declare class Logger {
+    readonly client: AtlanAI;
+    readonly projectName: string;
+    readonly asyncFlush: boolean;
+    constructor(client: AtlanAI, projectName: string, asyncFlush: boolean);
+    startSpan(name: string, options?: StartSpanOptions): AtlanSpan;
+    startSpan(args?: StartSpanArgs): AtlanSpan;
+    /** Run a callback with an automatically ended, ambient current span. */
+    traced<T>(callback: (span: AtlanSpan) => T, args?: StartSpanArgs): T;
+    /** Log one complete root event. Delivery is asynchronous by default. */
+    log(event: LogEvent): LoggedSpan;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+/**
+ * Initialize production tracing with Braintrust-style logger ergonomics.
+ *
+ * All OTel spans are accepted by default and handed to the existing background
+ * batch processor. Initialize this before provider/framework clients so their
+ * instrumentation acquires the same global OTel provider.
+ */
+export declare function initLogger(options?: InitLoggerOptions): Logger;
+/** The logger most recently initialized with `setCurrent !== false`. */
+export declare function currentLogger(): Logger | undefined;
+/** Active span, or a safe no-op span when no traced scope is active. */
+export declare function currentSpan(): AtlanSpan;
+/** Start a manual span from the current tracing client. */
+export declare function startSpan(name: string, options?: StartSpanOptions): AtlanSpan;
+export declare function startSpan(args?: StartSpanArgs): AtlanSpan;
+/** Run a callback in an automatically ended current span. */
+export declare function traced<T>(callback: (span: AtlanSpan) => T, args?: StartSpanArgs): T;
+/** Braintrust-compatible function wrapper, backed by `observe`. */
+export declare function wrapTraced<F extends AnyFunction>(fn: F, options?: WrapTracedOptions): F;
+/** Common alias used by other tracing SDKs. */
+export declare const traceable: typeof wrapTraced;
+export {};

package/dist/tracing/compat.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * Low-friction tracing compatibility helpers.
+ *
+ * The implementation deliberately reuses the SDK's OTel pipeline: ended spans
+ * enter its bounded background batcher, `flush()` drains that same queue, and
+ * third-party OTel instrumentation shares the same provider. There is no
+ * second transport or vendor-specific event format to keep in sync.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceable = exports.Logger = void 0;
+exports.initLogger = initLogger;
+exports.currentLogger = currentLogger;
+exports.currentSpan = currentSpan;
+exports.startSpan = startSpan;
+exports.traced = traced;
+exports.wrapTraced = wrapTraced;
+const client_js_1 = require("./client.js");
+const observe_js_1 = require("./observe.js");
+const LOGGER_SLOT = Symbol.for("atlanai.current-logger.v1");
+function loggerHost() {
+    return globalThis;
+}
+function allSpans(_) {
+    return true;
+}
+function spanArgs(nameOrArgs, options) {
+    if (typeof nameOrArgs === "string")
+        return { name: nameOrArgs, options };
+    const args = nameOrArgs ?? {};
+    const { name = "span", type, event, asType, fields, ...rest } = args;
+    return {
+        name,
+        options: {
+            ...rest,
+            ...(type === undefined && asType === undefined ? {} : { asType: type ?? asType }),
+            ...(event === undefined && fields === undefined ? {} : { fields: event ?? fields }),
+        },
+    };
+}
+/** A small logger facade over one Atlan OTel client. */
+class Logger {
+    client;
+    projectName;
+    asyncFlush;
+    constructor(client, projectName, asyncFlush) {
+        this.client = client;
+        this.projectName = projectName;
+        this.asyncFlush = asyncFlush;
+    }
+    startSpan(nameOrArgs, options = {}) {
+        const resolved = spanArgs(nameOrArgs, options);
+        return this.client.startSpan(resolved.name, resolved.options);
+    }
+    /** Run a callback with an automatically ended, ambient current span. */
+    traced(callback, args = {}) {
+        const resolved = spanArgs(args, {});
+        return this.client.startAsCurrentSpan(resolved.name, resolved.options, callback);
+    }
+    /** Log one complete root event. Delivery is asynchronous by default. */
+    log(event) {
+        const { name = "event", type = "task", ...fields } = event;
+        const span = this.client.startSpan(name, { asType: type, fields });
+        const identity = { traceId: span.traceId, spanId: span.spanId };
+        span.end();
+        if (!this.asyncFlush)
+            void this.client.flush();
+        return identity;
+    }
+    flush() {
+        return this.client.flush();
+    }
+    shutdown() {
+        return this.client.shutdown();
+    }
+}
+exports.Logger = Logger;
+/**
+ * Initialize production tracing with Braintrust-style logger ergonomics.
+ *
+ * All OTel spans are accepted by default and handed to the existing background
+ * batch processor. Initialize this before provider/framework clients so their
+ * instrumentation acquires the same global OTel provider.
+ */
+function initLogger(options = {}) {
+    const { projectName, projectId, serviceName, asyncFlush = true, captureAll = true, setCurrent = true, shouldExportSpan, ...initOptions } = options;
+    const resolvedName = serviceName ?? projectName ?? projectId ?? "global";
+    const exportPredicate = shouldExportSpan ?? (captureAll ? allSpans : undefined);
+    const client = (0, client_js_1.init)({
+        ...initOptions,
+        serviceName: resolvedName,
+        exportMode: asyncFlush ? "batch" : "immediate",
+        ...(exportPredicate === undefined ? {} : { shouldExportSpan: exportPredicate }),
+    });
+    const logger = new Logger(client, resolvedName, asyncFlush);
+    if (setCurrent)
+        loggerHost()[LOGGER_SLOT] = logger;
+    return logger;
+}
+/** The logger most recently initialized with `setCurrent !== false`. */
+function currentLogger() {
+    return loggerHost()[LOGGER_SLOT];
+}
+/** Active span, or a safe no-op span when no traced scope is active. */
+function currentSpan() {
+    return (0, client_js_1.getClient)().currentSpan();
+}
+function startSpan(nameOrArgs, options = {}) {
+    const resolved = spanArgs(nameOrArgs, options);
+    return (0, client_js_1.getClient)().startSpan(resolved.name, resolved.options);
+}
+/** Run a callback in an automatically ended current span. */
+function traced(callback, args = {}) {
+    const resolved = spanArgs(args, {});
+    return (0, client_js_1.getClient)().startAsCurrentSpan(resolved.name, resolved.options, callback);
+}
+/** Braintrust-compatible function wrapper, backed by `observe`. */
+function wrapTraced(fn, options = {}) {
+    const { type, asType, noTraceIO, captureInput, captureOutput, ...rest } = options;
+    return (0, observe_js_1.observe)(fn, {
+        ...rest,
+        ...(type === undefined && asType === undefined ? {} : { asType: type ?? asType }),
+        captureInput: noTraceIO ? false : (captureInput ?? true),
+        captureOutput: noTraceIO ? false : (captureOutput ?? true),
+    });
+}
+/** Common alias used by other tracing SDKs. */
+exports.traceable = wrapTraced;

package/dist/tracing/index.d.ts

@@ -9,6 +9,8 @@
 export { init, getClient, AtlanAI, _resetForTests, type InitOptions, type StartAsCurrentSpanOptions, type StartSpanOptions, type TraceContext, } from "./client.js";
 export { AtlanSpan, noopSpan, resolveSpanType, ROOT_SPAN_CONTEXT_KEY, type ScoreOptions, type UpdateFields, } from "./spans.js";
 export { observe, type ObserveOptions } from "./observe.js";
+export { aiTelemetry, wrapAISDK, type AITelemetryOptions, type AITelemetrySettings, } from "./integrations.js";
+export { Logger, currentLogger, currentSpan, initLogger, startSpan, traceable, traced, wrapTraced, type InitLoggerOptions, type LogEvent, type LoggedSpan, type StartSpanArgs, type WrapTracedOptions, } from "./compat.js";
 export { createSpanId, createSpanIdAsync, createTraceId, createTraceIdAsync } from "./ids.js";
 export { isMessageShaped, serializePayload, toJsonable, truncateUtf8, MAX_DEPTH, TRUNCATION_SUFFIX, } from "./serialize.js";
 export { AtlanConfigError, DEFAULT_BASE_URL, resolveConfig, type ConfigOptions, type Mode, type ResolvedConfig, } from "./config.js";

package/dist/tracing/index.js

@@ -41,7 +41,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.semconv = exports.SDK_VERSION = exports.SDK_LANGUAGE = exports.MaskingSpanExporter = exports.MASK_FAILURE_PLACEHOLDER = exports.applyMask = exports.AtlanSpanProcessor = exports.KNOWN_INSTRUMENTATION_SCOPE_PREFIXES = exports.isKnownInstrumentorSpan = exports.isGenAiSpan = exports.isAtlanSdkSpan = exports.defaultShouldExport = exports.ATLAN_SDK_SCOPE = exports.VisitorIdentifyError = exports.propagateAttributes = exports.resolveConfig = exports.DEFAULT_BASE_URL = exports.AtlanConfigError = exports.TRUNCATION_SUFFIX = exports.MAX_DEPTH = exports.truncateUtf8 = exports.toJsonable = exports.serializePayload = exports.isMessageShaped = exports.createTraceIdAsync = exports.createTraceId = exports.createSpanIdAsync = exports.createSpanId = exports.observe = exports.ROOT_SPAN_CONTEXT_KEY = exports.resolveSpanType = exports.noopSpan = exports.AtlanSpan = exports._resetForTests = exports.AtlanAI = exports.getClient = exports.init = void 0;
+exports.semconv = exports.SDK_VERSION = exports.SDK_LANGUAGE = exports.MaskingSpanExporter = exports.MASK_FAILURE_PLACEHOLDER = exports.applyMask = exports.AtlanSpanProcessor = exports.KNOWN_INSTRUMENTATION_SCOPE_PREFIXES = exports.isKnownInstrumentorSpan = exports.isGenAiSpan = exports.isAtlanSdkSpan = exports.defaultShouldExport = exports.ATLAN_SDK_SCOPE = exports.VisitorIdentifyError = exports.propagateAttributes = exports.resolveConfig = exports.DEFAULT_BASE_URL = exports.AtlanConfigError = exports.TRUNCATION_SUFFIX = exports.MAX_DEPTH = exports.truncateUtf8 = exports.toJsonable = exports.serializePayload = exports.isMessageShaped = exports.createTraceIdAsync = exports.createTraceId = exports.createSpanIdAsync = exports.createSpanId = exports.wrapTraced = exports.traced = exports.traceable = exports.startSpan = exports.initLogger = exports.currentSpan = exports.currentLogger = exports.Logger = exports.wrapAISDK = exports.aiTelemetry = exports.observe = exports.ROOT_SPAN_CONTEXT_KEY = exports.resolveSpanType = exports.noopSpan = exports.AtlanSpan = exports._resetForTests = exports.AtlanAI = exports.getClient = exports.init = void 0;
 var client_js_1 = require("./client.js");
 Object.defineProperty(exports, "init", { enumerable: true, get: function () { return client_js_1.init; } });
 Object.defineProperty(exports, "getClient", { enumerable: true, get: function () { return client_js_1.getClient; } });
@@ -54,6 +54,18 @@ Object.defineProperty(exports, "resolveSpanType", { enumerable: true, get: funct
 Object.defineProperty(exports, "ROOT_SPAN_CONTEXT_KEY", { enumerable: true, get: function () { return spans_js_1.ROOT_SPAN_CONTEXT_KEY; } });
 var observe_js_1 = require("./observe.js");
 Object.defineProperty(exports, "observe", { enumerable: true, get: function () { return observe_js_1.observe; } });
+var integrations_js_1 = require("./integrations.js");
+Object.defineProperty(exports, "aiTelemetry", { enumerable: true, get: function () { return integrations_js_1.aiTelemetry; } });
+Object.defineProperty(exports, "wrapAISDK", { enumerable: true, get: function () { return integrations_js_1.wrapAISDK; } });
+var compat_js_1 = require("./compat.js");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return compat_js_1.Logger; } });
+Object.defineProperty(exports, "currentLogger", { enumerable: true, get: function () { return compat_js_1.currentLogger; } });
+Object.defineProperty(exports, "currentSpan", { enumerable: true, get: function () { return compat_js_1.currentSpan; } });
+Object.defineProperty(exports, "initLogger", { enumerable: true, get: function () { return compat_js_1.initLogger; } });
+Object.defineProperty(exports, "startSpan", { enumerable: true, get: function () { return compat_js_1.startSpan; } });
+Object.defineProperty(exports, "traceable", { enumerable: true, get: function () { return compat_js_1.traceable; } });
+Object.defineProperty(exports, "traced", { enumerable: true, get: function () { return compat_js_1.traced; } });
+Object.defineProperty(exports, "wrapTraced", { enumerable: true, get: function () { return compat_js_1.wrapTraced; } });
 var ids_js_1 = require("./ids.js");
 Object.defineProperty(exports, "createSpanId", { enumerable: true, get: function () { return ids_js_1.createSpanId; } });
 Object.defineProperty(exports, "createSpanIdAsync", { enumerable: true, get: function () { return ids_js_1.createSpanIdAsync; } });

package/dist/tracing/integrations.d.ts

@@ -0,0 +1,35 @@
+/** Framework integration helpers that reuse the Atlan OpenTelemetry pipeline. */
+import type { Tracer } from "@opentelemetry/api";
+import { type Logger } from "./compat.js";
+export interface AITelemetryOptions {
+    /** Logger whose provider should create framework spans. Defaults to the current logger. */
+    logger?: Pick<Logger, "client">;
+    /** Vercel AI SDK function identifier. */
+    functionId?: string;
+    metadata?: Record<string, unknown>;
+    recordInputs?: boolean;
+    recordOutputs?: boolean;
+    /** Replace a tracer already present on the call. Defaults to false. */
+    replaceTracer?: boolean;
+}
+export interface AITelemetrySettings {
+    isEnabled: true;
+    tracer: Tracer;
+    functionId?: string;
+    metadata?: Record<string, unknown>;
+    recordInputs?: boolean;
+    recordOutputs?: boolean;
+}
+/**
+ * Build the native `experimental_telemetry` value used by Vercel AI SDK v3-v6.
+ * No Vercel dependency or vendor wrapper is required.
+ */
+export declare function aiTelemetry(options?: AITelemetryOptions): AITelemetrySettings;
+/**
+ * Braintrust-shaped Vercel AI SDK wrapper.
+ *
+ * Known generation/embedding functions and agent constructors receive native
+ * `experimental_telemetry`; all other exports pass through untouched. The
+ * returned proxy preserves the original namespace's types and lazy getters.
+ */
+export declare function wrapAISDK<T extends object>(sdk: T, options?: AITelemetryOptions): T;

package/dist/tracing/integrations.js

@@ -0,0 +1,95 @@
+"use strict";
+/** Framework integration helpers that reuse the Atlan OpenTelemetry pipeline. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiTelemetry = aiTelemetry;
+exports.wrapAISDK = wrapAISDK;
+const compat_js_1 = require("./compat.js");
+const client_js_1 = require("./client.js");
+/**
+ * Build the native `experimental_telemetry` value used by Vercel AI SDK v3-v6.
+ * No Vercel dependency or vendor wrapper is required.
+ */
+function aiTelemetry(options = {}) {
+    const client = options.logger?.client ?? (0, compat_js_1.currentLogger)()?.client ?? (0, client_js_1.getClient)();
+    return {
+        isEnabled: true,
+        tracer: client.tracerProvider?.getTracer("ai") ?? client.getTracer(),
+        ...(options.functionId === undefined ? {} : { functionId: options.functionId }),
+        ...(options.metadata === undefined ? {} : { metadata: options.metadata }),
+        ...(options.recordInputs === undefined ? {} : { recordInputs: options.recordInputs }),
+        ...(options.recordOutputs === undefined ? {} : { recordOutputs: options.recordOutputs }),
+    };
+}
+const AI_SDK_CALLS = new Set([
+    "embed",
+    "embedMany",
+    "generateObject",
+    "generateText",
+    "rerank",
+    "streamObject",
+    "streamText",
+]);
+const AI_SDK_AGENTS = new Set(["Agent", "Experimental_Agent", "ToolLoopAgent"]);
+function withTelemetry(input, options) {
+    const call = typeof input === "object" && input !== null && !Array.isArray(input)
+        ? input
+        : {};
+    const existing = typeof call.experimental_telemetry === "object" && call.experimental_telemetry !== null
+        ? call.experimental_telemetry
+        : {};
+    const generated = aiTelemetry(options);
+    const existingMetadata = typeof existing.metadata === "object" && existing.metadata !== null
+        ? existing.metadata
+        : {};
+    const metadata = { ...(options.metadata ?? {}), ...existingMetadata };
+    const tracer = options.replaceTracer === true || existing.tracer === undefined
+        ? generated.tracer
+        : existing.tracer;
+    return {
+        ...call,
+        experimental_telemetry: {
+            ...generated,
+            ...existing,
+            tracer,
+            ...(Object.keys(metadata).length === 0 ? {} : { metadata }),
+            isEnabled: true,
+        },
+    };
+}
+/**
+ * Braintrust-shaped Vercel AI SDK wrapper.
+ *
+ * Known generation/embedding functions and agent constructors receive native
+ * `experimental_telemetry`; all other exports pass through untouched. The
+ * returned proxy preserves the original namespace's types and lazy getters.
+ */
+function wrapAISDK(sdk, options = {}) {
+    const wrapped = new Map();
+    return new Proxy(sdk, {
+        get(target, property, receiver) {
+            const value = Reflect.get(target, property, receiver);
+            if (typeof property !== "string" ||
+                typeof value !== "function" ||
+                (!AI_SDK_CALLS.has(property) && !AI_SDK_AGENTS.has(property))) {
+                return value;
+            }
+            const cached = wrapped.get(property);
+            if (cached !== undefined)
+                return cached;
+            const proxy = new Proxy(value, {
+                apply(callable, thisArg, argumentsList) {
+                    const args = [...argumentsList];
+                    args[0] = withTelemetry(args[0], options);
+                    return Reflect.apply(callable, thisArg, args);
+                },
+                construct(callable, argumentsList, newTarget) {
+                    const args = [...argumentsList];
+                    args[0] = withTelemetry(args[0], options);
+                    return Reflect.construct(callable, args, newTarget);
+                },
+            });
+            wrapped.set(property, proxy);
+            return proxy;
+        },
+    });
+}

package/dist/tracing/spans.d.ts

@@ -55,6 +55,8 @@ export declare class AtlanSpan {
     _initialize(asType: string, asRoot: boolean): void;
     private serialize;
     update(fields: UpdateFields): this;
+    /** Braintrust-compatible spelling for incrementally adding span fields. */
+    log(fields: UpdateFields): this;
     /**
      * Emit a dedicated score child span (SPEC §9.4).
      *
@@ -71,5 +73,7 @@ export declare class AtlanSpan {
     /** Record an exception and mark the span ERROR (SPEC §9.2). */
     recordFailure(error: unknown): void;
     end(endTime?: TimeInput): void;
+    /** Braintrust-compatible spelling for ending a manually managed span. */
+    close(endTime?: TimeInput): void;
 }
 export declare function noopSpan(config: ResolvedConfig): AtlanSpan;

package/dist/tracing/spans.js

@@ -214,6 +214,10 @@ class AtlanSpan {
         }
         return this;
     }
+    /** Braintrust-compatible spelling for incrementally adding span fields. */
+    log(fields) {
+        return this.update(fields);
+    }
     /**
      * Emit a dedicated score child span (SPEC §9.4).
      *
@@ -314,6 +318,10 @@ class AtlanSpan {
     end(endTime) {
         this.otel.end(endTime);
     }
+    /** Braintrust-compatible spelling for ending a manually managed span. */
+    close(endTime) {
+        this.end(endTime);
+    }
 }
 exports.AtlanSpan = AtlanSpan;
 function noopSpan(config) {

package/dist/tracing/version.d.ts

@@ -1,4 +1,4 @@
 /** SDK identity (SPEC §2.2, §5.1). Kept in sync with package.json — the
  * version test fails the build on drift. */
 export declare const SDK_LANGUAGE = "typescript";
-export declare const SDK_VERSION = "0.2.1";
+export declare const SDK_VERSION = "0.2.2";

package/dist/tracing/version.js

@@ -4,4 +4,4 @@ exports.SDK_VERSION = exports.SDK_LANGUAGE = void 0;
 /** SDK identity (SPEC §2.2, §5.1). Kept in sync with package.json — the
  * version test fails the build on drift. */
 exports.SDK_LANGUAGE = "typescript";
-exports.SDK_VERSION = "0.2.1";
+exports.SDK_VERSION = "0.2.2";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlanai/sdk",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Atlan Agent Gateway management SDK",
   "type": "commonjs",
   "main": "./dist/index.js",

package/dist/raw/registry/apis/ActionsApi.d.ts

@@ -1,68 +0,0 @@
-/**
- * Atlan Agent Gateway — registry
- * The platform core: identity, tenancy, the artifact plane, discovery and the policy plane.
- *
- * The version of the OpenAPI document: 0.1.0
- *
- *
- * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
- * https://openapi-generator.tech
- * Do not edit the class manually.
- */
-import * as runtime from '../runtime';
-import { type ActionRunDto } from '../models/ActionRunDto';
-import { type ActionRunJobsPage } from '../models/ActionRunJobsPage';
-import { type ActionRunsPage } from '../models/ActionRunsPage';
-export interface RegistryGetActionRunRequest {
-    runId: string;
-}
-export interface RegistryListActionRunJobsRequest {
-    runId: string;
-}
-/**
- *
- */
-export declare class ActionsApi extends runtime.BaseAPI {
-    /**
-     * Creates request options for registryGetActionRun without sending the request
-     */
-    registryGetActionRunRequestOpts(requestParameters: RegistryGetActionRunRequest): Promise<runtime.RequestOpts>;
-    /**
-     * Use this operation to get an action run.
-     * Get an action run
-     */
-    registryGetActionRunRaw(requestParameters: RegistryGetActionRunRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ActionRunDto>>;
-    /**
-     * Use this operation to get an action run.
-     * Get an action run
-     */
-    registryGetActionRun(requestParameters: RegistryGetActionRunRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ActionRunDto>;
-    /**
-     * Creates request options for registryListActionRunJobs without sending the request
-     */
-    registryListActionRunJobsRequestOpts(requestParameters: RegistryListActionRunJobsRequest): Promise<runtime.RequestOpts>;
-    /**
-     * One row per DAG node: its status, its findings\' `max_severity`, and what it depended on. The run\'s own status is the roll-up; this is where a `failed` run says which node failed.
-     * List a run\'s job results
-     */
-    registryListActionRunJobsRaw(requestParameters: RegistryListActionRunJobsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ActionRunJobsPage>>;
-    /**
-     * One row per DAG node: its status, its findings\' `max_severity`, and what it depended on. The run\'s own status is the roll-up; this is where a `failed` run says which node failed.
-     * List a run\'s job results
-     */
-    registryListActionRunJobs(requestParameters: RegistryListActionRunJobsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ActionRunJobsPage>;
-    /**
-     * Creates request options for registryListActionRuns without sending the request
-     */
-    registryListActionRunsRequestOpts(): Promise<runtime.RequestOpts>;
-    /**
-     * Newest first, by `started_at` — a run is appended and then finished, never edited, so there is no `updated_at` to order by.  `run_status` is one of `pending`, `running`, `passed`, `failed`, `error`, `cancelled`, and the last three are three different facts. `failed` is a verdict — a scan found something. `error` is a malfunction — the scanner fell over; a broken extension must not read as a policy hit. `cancelled` is neither: the run was abandoned because its target artifact was archived, so there was nothing left to run it against. A `cancelled` run carries a `finished_at` and no `gate_outcome`, because it gated nothing.
-     * List action runs
-     */
-    registryListActionRunsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ActionRunsPage>>;
-    /**
-     * Newest first, by `started_at` — a run is appended and then finished, never edited, so there is no `updated_at` to order by.  `run_status` is one of `pending`, `running`, `passed`, `failed`, `error`, `cancelled`, and the last three are three different facts. `failed` is a verdict — a scan found something. `error` is a malfunction — the scanner fell over; a broken extension must not read as a policy hit. `cancelled` is neither: the run was abandoned because its target artifact was archived, so there was nothing left to run it against. A `cancelled` run carries a `finished_at` and no `gate_outcome`, because it gated nothing.
-     * List action runs
-     */
-    registryListActionRuns(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ActionRunsPage>;
-}