@agent-os-sdk/client 0.9.25 → 0.9.26

package/dist/modules/runs.js

@@ -1,536 +0,0 @@
-/**
- * Runs Module - Core execution API (Fully Typed)
- *
- * Naming conventions:
- * - get* for singular items
- * - list* for collections
- * - create*, update*, delete* for mutations
- */
-import { parseSSE } from "../sse/client.js";
-export class RunsModule {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    // ======================== CRUD ========================
-    /**
-     * Create a new run.
-     * @example
-     * ```ts
-     * const { data } = await client.runs.create({
-     *   agent_id: "agent-uuid",
-     *   input: { message: "Hello" }
-     * });
-     *
-     * // With idempotency (safe to retry)
-     * const { data } = await client.runs.create({
-     *   agent_id: "agent-uuid",
-     *   input: { message: "Hello" },
-     *   idempotency_key: "my-unique-key"
-     * });
-     * ```
-     */
-    async create(body) {
-        // Send canonical X-Idempotency-Key header + body idempotency_key for backend contract parity.
-        const headers = {};
-        if (body.idempotency_key) {
-            headers["X-Idempotency-Key"] = body.idempotency_key;
-        }
-        return this.client.POST("/v1/api/runs", {
-            body,
-            headers,
-        });
-    }
-    /**
-     * Get a run by ID.
-     */
-    async get(runId) {
-        return this.client.GET("/v1/api/runs/{runId}", {
-            params: { path: { runId } },
-        });
-    }
-    async getInspection(runId) {
-        return this.client.GET("/v1/api/runs/{runId}/inspection", {
-            params: { path: { runId } },
-        });
-    }
-    async listFailures(params) {
-        return this.client.GET("/v1/api/runs/failures", {
-            params: { query: params },
-        });
-    }
-    async getFailure(failureId) {
-        return this.client.GET("/v1/api/runs/failures/{failureId}", {
-            params: { path: { failureId } },
-        });
-    }
-    /**
-     * List runs with optional filters.
-     */
-    async list(params) {
-        return this.client.GET("/v1/api/runs", {
-            params: { query: params },
-        });
-    }
-    /**
-     * Iterate through all runs with automatic pagination.
-     *
-     * @example
-     * ```ts
-     * // Stream all completed runs
-     * for await (const run of client.runs.iterate({ status: "completed" })) {
-     *     console.log(run.run_id, run.status);
-     * }
-     *
-     * // With limit
-     * for await (const run of client.runs.iterate({ agent_id: "..." }, { maxItems: 100 })) {
-     *     processRun(run);
-     * }
-     * ```
-     */
-    async *iterate(filters, options) {
-        const pageSize = options?.pageSize ?? 100;
-        const maxItems = options?.maxItems ?? Infinity;
-        let offset = 0;
-        let yielded = 0;
-        let hasMore = true;
-        while (hasMore && yielded < maxItems) {
-            if (options?.signal?.aborted)
-                return;
-            const response = await this.list({
-                ...filters,
-                limit: Math.min(pageSize, maxItems - yielded),
-                offset,
-            });
-            if (response.error)
-                throw response.error;
-            const data = response.data;
-            for (const run of data.items) {
-                if (yielded >= maxItems)
-                    return;
-                yield run;
-                yielded++;
-            }
-            offset += data.items.length;
-            hasMore = offset < data.total && data.items.length > 0;
-        }
-    }
-    // ======================== Execution ========================
-    /**
-     * Wait for run completion synchronously.
-     */
-    async wait(body) {
-        return this.client.POST("/v1/api/runs/wait", {
-            body,
-        });
-    }
-    /**
-     * Create batch runs.
-     */
-    async batch(body) {
-        return this.client.POST("/v1/api/runs/batch", {
-            body,
-        });
-    }
-    /**
-     * Cancel a running run.
-     */
-    async cancel(runId, reason) {
-        return this.client.POST("/v1/api/runs/{runId}/cancel", {
-            params: { path: { runId } },
-            body: { reason },
-        });
-    }
-    async getObservabilitySummary(params) {
-        return this.client.GET("/v1/api/runs/observability/summary", {
-            params: { query: params },
-        });
-    }
-    async getObservabilityCapabilities(params) {
-        return this.client.GET("/v1/api/runs/observability/capabilities", {
-            params: { query: params },
-        });
-    }
-    async getObservabilityBindings(params) {
-        return this.client.GET("/v1/api/runs/observability/bindings", {
-            params: { query: params },
-        });
-    }
-    /**
-     * Resume a run waiting for human input (HITL).
-     * After the run reaches status 'waiting_for_human', use this to provide
-     * the human response and continue execution.
-     *
-     * @param runId - The run ID to resume
-     * @param body - The human input to provide
-     * @returns Updated run (status will change to 'resumed' then 'queued')
-     *
-     * @example
-     * ```ts
-     * // List runs waiting for human input
-     * const waiting = await client.runs.list({ status: 'waiting_for_human' })
-     *
-     * // Get the prompt
-     * const run = await client.runs.get(runId)
-     * console.log(run.human_prompt)  // "Deseja continuar com a compra?"
-     *
-     * // Respond
-     * await client.runs.resume(runId, { input: { answer: "sim" } })
-     * ```
-     */
-    async resume(runId, body) {
-        return this.client.POST("/v1/api/runs/{runId}/resume", {
-            params: { path: { runId } },
-            body,
-        });
-    }
-    /**
-     * Rerun from start (stateless).
-     */
-    async rerun(runId) {
-        return this.client.POST("/v1/api/runs/{runId}/rerun", {
-            params: { path: { runId } },
-        });
-    }
-    /**
-     * Replay from checkpoint (stateful).
-     * Creates a NEW run that starts from the specified checkpoint.
-     */
-    async replay(runId, checkpointId, options) {
-        return this.client.POST("/v1/api/runs/{runId}/checkpoints/{checkpointId}/replay", {
-            params: { path: { runId, checkpointId } },
-            body: {
-                mode: options?.mode,
-                reason: options?.reason
-            },
-        });
-    }
-    // ======================== Events ========================
-    /**
-     * Get canonical run events from SSOT ledger (polling by seq).
-     */
-    async getEvents(runId, params) {
-        return this.client.GET("/v1/api/runs/{runId}/events", {
-            params: {
-                path: { runId },
-                query: {
-                    attemptId: params.attemptId,
-                    afterSeq: params.afterSeq ?? 0,
-                    limit: params.limit ?? 100,
-                },
-            },
-        });
-    }
-    /** Alias: runs.events() -> runs.getEvents() */
-    events = (runId, params) => this.getEvents(runId, params);
-    /**
-     * Wave 2.3: Seq-based event polling for execution trace.
-     * Use this for incremental polling with reconnection support.
-     *
-     * @param runId - Run ID to poll events for
-     * @param params - Polling options
-     * @returns Events with seq cursors for pagination
-     *
-     * @example
-     * ```ts
-     * let afterSeq = 0;
-     * const attemptId = "attempt-uuid";
-     * while (run.status === 'running') {
-     *   const { data } = await client.runs.pollEvents(runId, { attemptId, afterSeq });
-     *   for (const event of data.events) {
-     *     console.log(event.type, event.payload);
-     *   }
-     *   afterSeq = data.next_after_seq;
-     *   await sleep(1000);
-     * }
-     * ```
-     */
-    async pollEvents(runId, params) {
-        return this.client.GET("/v1/api/runs/{runId}/events", {
-            params: {
-                path: { runId },
-                query: {
-                    attemptId: params.attemptId,
-                    afterSeq: params.afterSeq ?? 0,
-                    limit: params.limit ?? 100
-                }
-            },
-        });
-    }
-    // ======================== Checkpoints ========================
-    /**
-     * Get checkpoints for a run.
-     */
-    async getCheckpoints(runId) {
-        return this.client.GET("/v1/api/runs/{runId}/checkpoints/index", {
-            params: { path: { runId } },
-        });
-    }
-    /** Alias: runs.checkpoints() -> runs.getCheckpoints() */
-    checkpoints = (runId) => this.getCheckpoints(runId);
-    // ======================== FOLLOW (SSOT SSE) ========================
-    /**
-     * Follow a run attempt's canonical event stream with automatic reconnection.
-     *
-     * SSOT contract:
-     * - Stream is keyed by (run_id, attempt_id, seq)
-     * - Resume is driven by `afterSeq` (monotonic)
-     * - No implicit attempt inference
-     *
-     * @example
-     * ```ts
-     * for await (const event of client.runs.follow(runId, attemptId)) {
-     *     if (event.type === "run_event") {
-     *         console.log(event.payload);
-     *     } else if (event.type === "close") {
-     *         console.log("Run completed");
-     *     }
-     * }
-     * ```
-     */
-    async *follow(runId, attemptId, options) {
-        if (!attemptId) {
-            throw new Error("attemptId is required for run event streaming");
-        }
-        const signal = options?.signal;
-        const maxReconnects = options?.maxReconnects ?? 10;
-        const baseDelayMs = options?.baseDelayMs ?? 1000;
-        const maxDelayMs = options?.maxDelayMs ?? 30000;
-        // nextSeq = next seq we expect to receive (or 0 at start)
-        let nextSeq = options?.startSeq ?? 0;
-        let reconnectCount = 0;
-        let receivedTerminal = false;
-        options?.onConnect?.();
-        while (!receivedTerminal && reconnectCount <= maxReconnects) {
-            if (signal?.aborted)
-                return;
-            try {
-                // Build headers - Last-Event-ID is the LAST seq we received (nextSeq - 1)
-                const headers = {};
-                if (nextSeq > 0) {
-                    headers["Last-Event-ID"] = String(nextSeq - 1);
-                }
-                const response = await this.client.streamGet("/v1/api/runs/{runId}/events/stream", {
-                    params: {
-                        path: { runId },
-                        query: {
-                            attemptId,
-                            afterSeq: nextSeq > 0 ? nextSeq : 0,
-                        },
-                    },
-                    headers,
-                });
-                // Check for auth errors - don't reconnect on these
-                if (response.status === 401 || response.status === 403) {
-                    const errorEvent = {
-                        type: "error",
-                        payload: { code: `HTTP_${response.status}`, message: response.statusText },
-                        seq: -1,
-                        timestamp: new Date().toISOString(),
-                    };
-                    yield errorEvent;
-                    return; // Don't reconnect on auth errors
-                }
-                if (!response.ok) {
-                    throw new Error(`SSE connection failed: ${response.status}`);
-                }
-                // Reset reconnect count on successful connection
-                if (reconnectCount > 0) {
-                    options?.onReconnect?.(reconnectCount);
-                }
-                reconnectCount = 0;
-                // Parse SSE stream
-                for await (const rawEvent of parseSSE(response)) {
-                    if (signal?.aborted)
-                        return;
-                    // Narrow to known event types
-                    const event = narrowFollowEvent(rawEvent);
-                    if (!event)
-                        continue; // Skip unknown event types
-                    // Update seq tracking if event has seq
-                    if (typeof event.seq === "number" && event.seq >= 0) {
-                        nextSeq = event.seq + 1;
-                    }
-                    if (event.type === "error") {
-                        // Error event from server - yield but continue (might reconnect)
-                        yield event;
-                        // If it's a fatal error, break and try reconnect
-                        break;
-                    }
-                    yield event;
-                    if (event.type === "run_event" && isTerminalRunEvent(event)) {
-                        receivedTerminal = true;
-                        yield {
-                            type: "close",
-                            seq: event.seq,
-                            timestamp: event.timestamp,
-                            payload: { terminal: true },
-                        };
-                        return;
-                    }
-                }
-                // Stream ended without close event - this is unexpected EOF
-                // Reconnect unless we already received terminal
-                if (!receivedTerminal && !signal?.aborted) {
-                    options?.onDisconnect?.("eof");
-                    reconnectCount++;
-                    if (reconnectCount <= maxReconnects) {
-                        await sleep(calculateBackoff(reconnectCount, baseDelayMs, maxDelayMs));
-                    }
-                }
-            }
-            catch (err) {
-                if (signal?.aborted)
-                    return;
-                options?.onDisconnect?.("error");
-                reconnectCount++;
-                if (reconnectCount <= maxReconnects) {
-                    await sleep(calculateBackoff(reconnectCount, baseDelayMs, maxDelayMs));
-                }
-                else {
-                    // Max reconnects exceeded - yield error and stop
-                    yield {
-                        type: "error",
-                        payload: { code: "MAX_RECONNECTS", message: `Max reconnects (${maxReconnects}) exceeded` },
-                        seq: -1,
-                        timestamp: new Date().toISOString(),
-                    };
-                    return;
-                }
-            }
-        }
-    }
-    /**
-     * Create run and follow canonical SSOT stream for the current attempt.
-     */
-    async *createAndStream(body, options) {
-        const { data, error } = await this.create(body);
-        if (error || !data) {
-            throw new Error(`Failed to create run: ${JSON.stringify(error)}`);
-        }
-        const runId = data.run_id;
-        const runResponse = await this.get(runId);
-        if (runResponse.error || !runResponse.data?.current_attempt_id) {
-            throw new Error("Run created without current_attempt_id; cannot stream SSOT events");
-        }
-        yield* this.follow(runId, runResponse.data.current_attempt_id, options);
-    }
-    /**
-     * Wait for a specific event that matches a predicate.
-     *
-     * @example
-     * ```ts
-     * // Wait for run completion
-     * const event = await client.runs.waitFor(runId, attemptId, (e) => e.type === "close", {
-     *     timeoutMs: 60000
-     * });
-     *
-     * // Wait for specific node execution
-     * const nodeEvent = await client.runs.waitFor(runId, attemptId, (e) =>
-     *     e.type === "run_event" && e.payload?.node === "my_node"
-     * );
-     * ```
-     */
-    async waitFor(runId, attemptId, predicate, options) {
-        const timeoutMs = options?.timeoutMs ?? 300_000; // 5 min default
-        const controller = new AbortController();
-        // Combine parent signal with our timeout
-        const onAbort = () => controller.abort();
-        options?.signal?.addEventListener("abort", onAbort, { once: true });
-        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-        try {
-            for await (const event of this.follow(runId, attemptId, {
-                signal: controller.signal,
-                startSeq: options?.startSeq,
-            })) {
-                if (predicate(event)) {
-                    return event;
-                }
-                // If we got close without matching predicate, error
-                if (event.type === "close") {
-                    throw new Error("Run completed without matching event");
-                }
-            }
-            // Stream ended without match or terminal
-            throw new Error("Stream ended without matching event");
-        }
-        catch (err) {
-            if (controller.signal.aborted && !options?.signal?.aborted) {
-                // Our timeout triggered the abort
-                const { TimeoutError } = await import("../errors/index.js");
-                throw new TimeoutError(timeoutMs);
-            }
-            throw err;
-        }
-        finally {
-            clearTimeout(timeoutId);
-            options?.signal?.removeEventListener("abort", onAbort);
-        }
-    }
-}
-/** Narrow raw SSE event to FollowEvent */
-export function narrowFollowEvent(raw) {
-    const eventType = raw.event ?? "message";
-    const validTypes = ["run_event", "heartbeat", "close", "error"];
-    if (!validTypes.includes(eventType)) {
-        return null;
-    }
-    const data = raw.data;
-    // Canonical payload from backend SSE is RunEventDto:
-    // { id, seq, type, timestamp, attempt_id, payload }
-    if (eventType === "run_event" && data) {
-        const seq = typeof data.seq === "number" ? data.seq : (raw.id ? parseInt(raw.id, 10) : -1);
-        const timestamp = typeof data.timestamp === "string" ? data.timestamp : new Date().toISOString();
-        const innerPayload = (typeof data.payload === "object" && data.payload !== null)
-            ? data.payload
-            : null;
-        const operationId = typeof data.operation_id === "string" ? data.operation_id : undefined;
-        const parentOperationId = typeof data.parent_operation_id === "string"
-            ? data.parent_operation_id
-            : data.parent_operation_id === null
-                ? null
-                : undefined;
-        const rootOperationId = typeof data.root_operation_id === "string" ? data.root_operation_id : undefined;
-        return {
-            type: "run_event",
-            seq,
-            timestamp,
-            payload: {
-                ...(innerPayload ?? {}),
-                type: typeof data.type === "string" ? data.type : "UNKNOWN",
-                attempt_id: typeof data.attempt_id === "string" ? data.attempt_id : undefined,
-                operation_id: operationId,
-                parent_operation_id: parentOperationId,
-                root_operation_id: rootOperationId,
-            },
-            operation_id: operationId,
-            parent_operation_id: parentOperationId,
-            root_operation_id: rootOperationId,
-            node: typeof innerPayload?.node === "string" ? innerPayload.node : undefined,
-        };
-    }
-    return {
-        type: eventType,
-        seq: typeof data?.seq === "number" ? data.seq : (raw.id ? parseInt(raw.id, 10) : -1),
-        timestamp: typeof data?.timestamp === "string" ? data.timestamp : new Date().toISOString(),
-        payload: data,
-        node: typeof data?.node === "string" ? data.node : undefined,
-    };
-}
-function isTerminalRunEvent(event) {
-    const type = typeof event.payload?.type === "string"
-        ? event.payload.type.toUpperCase()
-        : "";
-    return type === "RUN_FINISHED" || type === "RUN_FAILED" || type === "RUN_CANCELLED";
-}
-/** Calculate exponential backoff with jitter */
-function calculateBackoff(attempt, baseMs, maxMs) {
-    const exponential = baseMs * Math.pow(2, attempt - 1);
-    const capped = Math.min(exponential, maxMs);
-    const jitter = capped * 0.2 * Math.random();
-    return Math.floor(capped + jitter);
-}
-/** Sleep utility */
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}

package/dist/modules/store.d.ts

@@ -1,37 +0,0 @@
-/**
- * Store Module - Fully Typed
- */
-import type { RawClient, APIResponse } from "../client/raw.js";
-export interface StoreValue {
-    key: string;
-    value: string;
-    ttl_seconds?: number;
-    created_at: string;
-    expires_at?: string;
-}
-export interface StoreKeysResponse {
-    keys: string[];
-    total: number;
-}
-export declare class StoreModule {
-    private client;
-    private headers;
-    constructor(client: RawClient, headers: () => Record<string, string>);
-    /**
-     * Get a value by key.
-     */
-    get(key: string): Promise<APIResponse<StoreValue>>;
-    /**
-     * Set a value.
-     */
-    set(key: string, value: string, ttlSeconds?: number): Promise<APIResponse<StoreValue>>;
-    /**
-     * Delete a value.
-     */
-    delete(key: string): Promise<APIResponse<void>>;
-    /**
-     * List all keys.
-     */
-    listKeys(prefix?: string): Promise<APIResponse<StoreKeysResponse>>;
-}
-//# sourceMappingURL=store.d.ts.map

package/dist/modules/store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/modules/store.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAc,MAAM,kBAAkB,CAAC;AAI3E,MAAM,WAAW,UAAU;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAC9B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,WAAW;IACR,OAAO,CAAC,MAAM;IAAa,OAAO,CAAC,OAAO;gBAAlC,MAAM,EAAE,SAAS,EAAU,OAAO,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAEpF;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;IAOxD;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;IAQ5F;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAOrD;;OAEG;IACG,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,iBAAiB,CAAC,CAAC;CAM3E"}

package/dist/modules/store.js

@@ -1,48 +0,0 @@
-/**
- * Store Module - Fully Typed
- */
-export class StoreModule {
-    client;
-    headers;
-    constructor(client, headers) {
-        this.client = client;
-        this.headers = headers;
-    }
-    /**
-     * Get a value by key.
-     */
-    async get(key) {
-        return this.client.GET("/v1/api/store/{key}", {
-            params: { path: { key } },
-            headers: this.headers(),
-        });
-    }
-    /**
-     * Set a value.
-     */
-    async set(key, value, ttlSeconds) {
-        return this.client.PUT("/v1/api/store/{key}", {
-            params: { path: { key } },
-            body: { value, ttl_seconds: ttlSeconds },
-            headers: this.headers(),
-        });
-    }
-    /**
-     * Delete a value.
-     */
-    async delete(key) {
-        return this.client.DELETE("/v1/api/store/{key}", {
-            params: { path: { key } },
-            headers: this.headers(),
-        });
-    }
-    /**
-     * List all keys.
-     */
-    async listKeys(prefix) {
-        return this.client.GET("/v1/api/store", {
-            params: { query: { prefix } },
-            headers: this.headers(),
-        });
-    }
-}

package/dist/modules/templates.d.ts

@@ -1,28 +0,0 @@
-import type { APIResponse, RawClient } from "../client/raw.js";
-export interface AuthoringTemplateSummary {
-    template_ref: string;
-    version: string;
-    display_name: string;
-    description?: string | null;
-    template_kind: string;
-    category: string;
-    editability_mode: string;
-    required_capability_refs: string[];
-    default_policy_refs?: Record<string, unknown> | null;
-    default_runtime_config_refs?: Record<string, unknown> | null;
-}
-export interface AuthoringTemplateDetail extends AuthoringTemplateSummary {
-    base_agent_ir: Record<string, unknown>;
-}
-export interface AuthoringTemplateListResponse {
-    items: AuthoringTemplateSummary[];
-    total: number;
-}
-export declare class TemplatesModule {
-    private client;
-    private headers;
-    constructor(client: RawClient, headers: () => Record<string, string>);
-    list(): Promise<APIResponse<AuthoringTemplateListResponse>>;
-    get(templateRef: string): Promise<APIResponse<AuthoringTemplateDetail>>;
-}
-//# sourceMappingURL=templates.d.ts.map

package/dist/modules/templates.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../src/modules/templates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE/D,MAAM,WAAW,wBAAwB;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,wBAAwB,EAAE,MAAM,EAAE,CAAC;IACnC,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACrD,2BAA2B,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAChE;AAED,MAAM,WAAW,uBAAwB,SAAQ,wBAAwB;IACrE,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC1C;AAED,MAAM,WAAW,6BAA6B;IAC1C,KAAK,EAAE,wBAAwB,EAAE,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,eAAe;IACZ,OAAO,CAAC,MAAM;IAAa,OAAO,CAAC,OAAO;gBAAlC,MAAM,EAAE,SAAS,EAAU,OAAO,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAE9E,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC,6BAA6B,CAAC,CAAC;IAM3D,GAAG,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,uBAAuB,CAAC,CAAC;CAMhF"}

package/dist/modules/templates.js

@@ -1,19 +0,0 @@
-export class TemplatesModule {
-    client;
-    headers;
-    constructor(client, headers) {
-        this.client = client;
-        this.headers = headers;
-    }
-    async list() {
-        return this.client.GET("/v1/api/templates", {
-            headers: this.headers(),
-        });
-    }
-    async get(templateRef) {
-        return this.client.GET("/v1/api/templates/{templateRef}", {
-            params: { path: { templateRef } },
-            headers: this.headers(),
-        });
-    }
-}