@inodra/sui 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,504 @@
+import { I as InodraAuth, a as InodraNetwork, b as INODRA_ENDPOINTS } from './network-CEg2MJY3.js';
+export { A as AuthCredentials, r as resolveAuth } from './network-CEg2MJY3.js';
+import { I as InodraHttpClient, S as Success, O as Operation, Q as Query, u as components, B as Body, h as CreateStreamResponse, d as CreateEventStreamInput, C as CreateAddressStreamInput, b as CreateCoinStreamInput, f as CreateObjectStreamInput, L as ListStreamsResponse, W as WarpStream, U as UpdateStreamInput, p as UpdateStreamResponse, D as DeleteStreamResponse, e as CreateEventWebhookInput, i as CreateWebhookResponse, a as CreateAddressWebhookInput, c as CreateCoinWebhookInput, g as CreateObjectWebhookInput, o as ListWebhooksResponse, s as Webhook, q as UpdateWebhookInput, r as UpdateWebhookResponse, j as DeleteWebhookResponse, n as InodraResponseMeta } from './index-CGBN_EI5.js';
+export { k as InodraHttpClientOptions, l as InodraManagementClient, m as InodraManagementClientOptions, P as Page, R as RequestOptions, t as paginate } from './index-CGBN_EI5.js';
+import { SuiGraphQLClient } from '@mysten/sui/graphql';
+import { SuiGrpcClient } from '@mysten/sui/grpc';
+import * as zod from 'zod';
+import * as zod_v4_core from 'zod/v4/core';
+import { aC as EventSchemaReflector, C as CatalogEventId, a as CatalogEventPayload, d4 as WarpEventPayload, d6 as WebhookEventBody } from './reflection-Bx44-Fs1.js';
+import { WarpSseStream, WarpWebSocketStream, WarpSseStreamOptions, WarpWebSocketStreamOptions } from './warp.js';
+export { IterateStreamOptions, WarpConnectedInfo, WarpEvent, WarpStreamEvents, WarpStreamOptions, iterateStream } from './warp.js';
+import { VerifyWebhookSignatureOptions } from './webhooks.js';
+export { verifyWebhookSignature } from './webhooks.js';
+
+type MeOp = Operation<"/auth/me", "get">;
+type UsageOp = Operation<"/usage/stats", "get">;
+/**
+ * The authenticated principal: API key introspection and usage/billing stats.
+ *
+ * ```ts
+ * const me = await inodra.account.me();       // org, project, network, tier
+ * const usage = await inodra.account.usage(); // CU consumed/remaining, p95s
+ * ```
+ */
+declare class AccountNamespace {
+    private readonly http;
+    constructor(http: InodraHttpClient);
+    /** Who am I — key, organization, project, network, tier, subscription. */
+    me(): Promise<Success<MeOp>>;
+    /** Usage stats for the current billing period (CU, requests, latency). */
+    usage(): Promise<Success<UsageOp>>;
+}
+
+type ProtocolsOp = Operation<"/catalog/protocols", "get">;
+type EventsOp = Operation<"/catalog/events", "get">;
+/**
+ * Curated protocol event catalog — the live counterpart of the generated
+ * schemas in `@inodra/sui/events`. Use it to browse protocols/events and
+ * pre-fill webhook or Warp subscriptions with canonical event types.
+ */
+declare class CatalogNamespace {
+    private readonly http;
+    constructor(http: InodraHttpClient);
+    protocols(query?: Query<ProtocolsOp>): Promise<Success<ProtocolsOp>>;
+    events(query?: Query<EventsOp>): Promise<Success<EventsOp>>;
+}
+
+type AccountOp = Operation<"/accounts/{address}", "get">;
+type BalanceOp = Operation<"/accounts/{address}/balance", "get">;
+type AccountObjectsOp = Operation<"/accounts/{address}/objects", "get">;
+type AccountTxsOp = Operation<"/accounts/{address}/transactions", "get">;
+type DelegationsOp = Operation<"/accounts/{address}/delegations", "get">;
+type CoinOp = Operation<"/coins/{coinType}", "get">;
+type CoinMetadataOp = Operation<"/coins/type/{coinType}", "get">;
+type ObjectMetadataOp = Operation<"/objects/metadata", "post">;
+type ObjectTxsOp = Operation<"/objects/{objectId}/transactions", "get">;
+type PackageOp = Operation<"/packages/{packageId}", "get">;
+type ChainInfoOp = Operation<"/chain/info", "get">;
+type ChainStakingOp = Operation<"/chain/staking", "get">;
+type ChainStatsOp = Operation<"/chain/stats", "get">;
+type ValidatorsOp = Operation<"/validators", "get">;
+type ValidatorsApyOp = Operation<"/validators/apy", "get">;
+type ValidatorsCommissionOp = Operation<"/validators/commission", "get">;
+type ValidatorOp = Operation<"/validators/{validatorAddress}", "get">;
+type SuinsResolveOp = Operation<"/suins/resolve/{name}", "get">;
+type SuinsReverseOp = Operation<"/suins/reverse/{address}", "get">;
+type SuinsBatchOp = Operation<"/suins/resolve/batch", "post">;
+type SuinsAvailabilityOp = Operation<"/suins/availability/{name}", "get">;
+/**
+ * Indexer-backed data API: accounts, coins, objects, packages, chain,
+ * validators, and SuiNS. Mainnet only (testnet projects get 403 on these).
+ *
+ * ```ts
+ * const balance = await inodra.data.accounts.balance("0x...");
+ * for await (const tx of inodra.data.accounts.iterateTransactions("0x...")) { … }
+ * ```
+ */
+declare class DataNamespace {
+    private readonly http;
+    constructor(http: InodraHttpClient);
+    readonly accounts: {
+        get: (address: string) => Promise<Success<AccountOp>>;
+        balance: (address: string) => Promise<Success<BalanceOp>>;
+        objects: (address: string, query?: Query<AccountObjectsOp>) => Promise<Success<AccountObjectsOp>>;
+        /** Every owned object, walking all pages lazily. */
+        iterateObjects: (address: string, query?: Query<AccountObjectsOp>) => AsyncGenerator<{
+            data?: components["schemas"]["SuiObject"];
+            error?: string;
+        }, void, undefined>;
+        transactions: (address: string, query?: Query<AccountTxsOp>) => Promise<Success<AccountTxsOp>>;
+        /** Every transaction, walking all pages lazily. */
+        iterateTransactions: (address: string, query?: Query<AccountTxsOp>) => AsyncGenerator<{
+            digest: string;
+            checkpoint?: string | null;
+            timestampMs?: string | null;
+            transaction?: unknown;
+            effects?: unknown;
+            events?: {
+                id: {
+                    txDigest: string;
+                    eventSeq: string;
+                };
+                packageId?: string | null;
+                transactionModule?: string | null;
+                sender?: string | null;
+                type: string;
+                timestampMs?: string | null;
+            }[] | null;
+            objectChanges?: unknown[] | null;
+            balanceChanges?: {
+                owner: {
+                    [key: string]: string;
+                };
+                coinType: string;
+                amount: string;
+            }[] | null;
+            confirmedLocalExecution?: boolean | null;
+            errors?: string[];
+        } | {
+            type: "sent" | "received";
+            transactionDigest: string;
+            timestamp?: string;
+            amount?: string | null;
+            coinType?: string | null;
+            counterparty?: string | null;
+            transaction: components["schemas"]["SuiTransactionBlockResponse"];
+        }, void, undefined>;
+        delegations: (address: string) => Promise<Success<DelegationsOp>>;
+    };
+    readonly coins: {
+        /** Coin denomination (supply, holders, decimals, …). */
+        get: (coinType: string) => Promise<Success<CoinOp>>;
+        /** Display metadata: name, symbol, icon, description, links. */
+        metadata: (coinType: string) => Promise<Success<CoinMetadataOp>>;
+    };
+    readonly objects: {
+        /** Metadata (type, name, image, project) for one object id. */
+        metadata: (input: Body<ObjectMetadataOp>) => Promise<Success<ObjectMetadataOp>>;
+        transactions: (objectId: string, query?: Query<ObjectTxsOp>) => Promise<Success<ObjectTxsOp>>;
+        /** Every transaction touching the object, walking all pages lazily. */
+        iterateTransactions: (objectId: string, query?: Query<ObjectTxsOp>) => AsyncGenerator<{
+            digest: string;
+            checkpoint?: string | null;
+            timestampMs?: string | null;
+            transaction?: unknown;
+            effects?: unknown;
+            events?: {
+                id: {
+                    txDigest: string;
+                    eventSeq: string;
+                };
+                packageId?: string | null;
+                transactionModule?: string | null;
+                sender?: string | null;
+                type: string;
+                timestampMs?: string | null;
+            }[] | null;
+            objectChanges?: unknown[] | null;
+            balanceChanges?: {
+                owner: {
+                    [key: string]: string;
+                };
+                coinType: string;
+                amount: string;
+            }[] | null;
+            confirmedLocalExecution?: boolean | null;
+            errors?: string[];
+        }, void, undefined>;
+    };
+    readonly packages: {
+        get: (packageId: string) => Promise<Success<PackageOp>>;
+    };
+    readonly chain: {
+        info: () => Promise<Success<ChainInfoOp>>;
+        staking: () => Promise<Success<ChainStakingOp>>;
+        stats: () => Promise<Success<ChainStatsOp>>;
+    };
+    readonly validators: {
+        list: (query?: Query<ValidatorsOp>) => Promise<Success<ValidatorsOp>>;
+        apy: () => Promise<Success<ValidatorsApyOp>>;
+        commission: () => Promise<Success<ValidatorsCommissionOp>>;
+        get: (validatorAddress: string) => Promise<Success<ValidatorOp>>;
+    };
+    readonly suins: {
+        /** SuiNS name → address. */
+        resolve: (name: string) => Promise<Success<SuinsResolveOp>>;
+        /** Address → primary SuiNS name. */
+        reverse: (address: string) => Promise<Success<SuinsReverseOp>>;
+        resolveBatch: (input: Body<SuinsBatchOp>) => Promise<Success<SuinsBatchOp>>;
+        availability: (name: string) => Promise<Success<SuinsAvailabilityOp>>;
+    };
+}
+
+interface EventsNamespaceContext {
+    auth: InodraAuth;
+    network: InodraNetwork;
+    /** GraphQL endpoint override (custom endpoints). */
+    graphqlUrl?: string;
+    fetch?: typeof globalThis.fetch;
+}
+/**
+ * Typed payloads for ARBITRARY Move events (beyond the curated catalog) via
+ * on-chain struct reflection. Schemas are built once and cached per type.
+ *
+ * ```ts
+ * const schema = await inodra.events.schemaFor("0xpkg::vault::Deposit<0x2::sui::SUI>");
+ * stream.on("message", async (msg) => {
+ *   const payload = await inodra.events.parseEvent(msg, "0xpkg::vault::Deposit");
+ *   if (payload) console.log(payload.amount); // validated + normalized
+ * });
+ * ```
+ *
+ * For catalog events prefer the statically-typed helpers in
+ * `@inodra/sui/events` (`parseCatalogEvent`) — reflection is for your own
+ * or uncataloged protocols. The zod machinery loads on first use.
+ */
+declare class EventsNamespace {
+    private readonly ctx;
+    private reflectorPromise;
+    constructor(ctx: EventsNamespaceContext);
+    /** The underlying reflector (shared cache across calls). */
+    reflector(): Promise<EventSchemaReflector>;
+    /**
+     * Build (and cache) a loose, normalizing zod schema for any concrete
+     * Move event type, by reflecting its struct layout on-chain. Generic
+     * types are typed concretely from their instantiation.
+     */
+    schemaFor(type: string): Promise<zod.ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
+    /**
+     * Validate + normalize an event payload against the reflected schema.
+     * Accepts a Warp stream message, a bare event payload, or a webhook
+     * body. Returns undefined for other event types; throws on schema
+     * mismatch. Pass a base type (no `<…>`) to match every instantiation —
+     * each is reflected and typed concretely.
+     */
+    parseEvent(message: unknown, type: string): Promise<Record<string, unknown> | undefined>;
+}
+
+interface WarpNamespaceContext {
+    http: InodraHttpClient;
+    auth: InodraAuth;
+    network: InodraNetwork;
+    /** REST base URL override (custom endpoints) — used for SSE stream URLs. */
+    restBaseUrl?: string;
+    /** WS base URL override (custom endpoints). */
+    warpWsBaseUrl?: string;
+    /** Custom fetch implementation, threaded into SSE streams. */
+    fetch?: typeof globalThis.fetch;
+}
+type ConnectOptions = Omit<WarpSseStreamOptions, "auth" | "apiKey" | "subscriptionId" | "network">;
+type ConnectWebSocketOptions = Omit<WarpWebSocketStreamOptions, "auth" | "apiKey" | "subscriptionId" | "network">;
+interface StreamCatalogEventOptions extends ConnectOptions, ConnectWebSocketOptions {
+    /** Optional sender address filter for the subscription. */
+    sender?: CreateEventStreamInput["sender"];
+    /** Optional field-level filters for the subscription (max 10). */
+    eventFieldFilters?: CreateEventStreamInput["eventFieldFilters"];
+    /** Delivery transport. Defaults to "sse". */
+    transport?: "sse" | "ws";
+    /**
+     * Delete the subscription when the stream closes or iteration ends.
+     * Defaults to false — pass true for one-off consumers so they don't
+     * accumulate subscriptions against the plan limit. Note: if the process
+     * dies before close(), the subscription survives; give long-lived
+     * consumers a managed subscription instead.
+     */
+    ephemeral?: boolean;
+}
+/** A typed catalog event with its delivery envelope. */
+interface CatalogEventMessage<Id extends CatalogEventId> {
+    /** Validated, normalized Move event payload. */
+    payload: CatalogEventPayload<Id>;
+    /** Delivery envelope: txDigest, checkpoint, timestamp, sender, raw type. */
+    envelope: WarpEventPayload;
+}
+interface CatalogEventStream<Id extends CatalogEventId> extends AsyncIterable<CatalogEventMessage<Id>> {
+    /** The created Warp subscription (delete it when done unless ephemeral). */
+    subscription: CreateStreamResponse["data"];
+    /** The underlying transport stream (for on("error"), lastEventId, …). */
+    stream: WarpSseStream | WarpWebSocketStream;
+    /** Close the stream; deletes the subscription when ephemeral. */
+    close(): Promise<void>;
+}
+/**
+ * Warp streams: subscription CRUD plus live SSE/WebSocket delivery.
+ *
+ * ```ts
+ * const sub = await inodra.warp.createEventStream({ eventType });
+ * const stream = inodra.warp.connect(sub.id);
+ * stream.on("message", (event) => console.log(event.data));
+ * ```
+ */
+declare class WarpNamespace {
+    private readonly ctx;
+    constructor(ctx: WarpNamespaceContext);
+    createEventStream(input: CreateEventStreamInput): Promise<CreateStreamResponse>;
+    createAddressStream(input: CreateAddressStreamInput): Promise<CreateStreamResponse>;
+    createCoinStream(input: CreateCoinStreamInput): Promise<CreateStreamResponse>;
+    createObjectStream(input: CreateObjectStreamInput): Promise<CreateStreamResponse>;
+    list(): Promise<ListStreamsResponse>;
+    get(id: string): Promise<WarpStream>;
+    update(id: string, input: UpdateStreamInput): Promise<UpdateStreamResponse>;
+    delete(id: string): Promise<DeleteStreamResponse>;
+    /**
+     * Open an SSE connection to a Warp subscription and start it.
+     * At-least-once delivery; reconnects resume from the last event ID.
+     */
+    connect(subscriptionId: string, options?: ConnectOptions): WarpSseStream;
+    /**
+     * Open a WebSocket connection to a Warp subscription and start it.
+     * Exactly-once delivery via acks (automatic by default).
+     */
+    connectWebSocket(subscriptionId: string, options?: ConnectWebSocketOptions): WarpWebSocketStream;
+    /**
+     * One call from catalog id to typed live events: resolves the event's
+     * canonical type for this network, creates the subscription, connects,
+     * and yields validated payloads.
+     *
+     * ```ts
+     * const swaps = await inodra.warp.streamCatalogEvent("cetus.swap", {
+     *   ephemeral: true,
+     * });
+     * for await (const { payload, envelope } of swaps) {
+     *   console.log(envelope.txDigest, payload.amount_in);
+     * }
+     * ```
+     */
+    streamCatalogEvent<Id extends CatalogEventId>(id: Id, options?: StreamCatalogEventOptions): Promise<CatalogEventStream<Id>>;
+    private sseUrl;
+    private wsUrl;
+}
+
+/**
+ * Webhooks: subscription CRUD plus delivery signature verification.
+ *
+ * ```ts
+ * const hook = await inodra.webhooks.createEvent({ eventType, url });
+ * // in your receiver:
+ * const valid = await inodra.webhooks.verifySignature({ payload, signature, secret });
+ * ```
+ */
+declare class WebhooksNamespace {
+    private readonly http;
+    constructor(http: InodraHttpClient);
+    createEvent(input: CreateEventWebhookInput): Promise<CreateWebhookResponse>;
+    createAddress(input: CreateAddressWebhookInput): Promise<CreateWebhookResponse>;
+    createCoin(input: CreateCoinWebhookInput): Promise<CreateWebhookResponse>;
+    createObject(input: CreateObjectWebhookInput): Promise<CreateWebhookResponse>;
+    list(): Promise<ListWebhooksResponse>;
+    get(id: string): Promise<Webhook>;
+    update(id: string, input: UpdateWebhookInput): Promise<UpdateWebhookResponse>;
+    delete(id: string): Promise<DeleteWebhookResponse>;
+    /** Verify an incoming webhook delivery's X-Inodra-Signature header. */
+    verifySignature(options: VerifyWebhookSignatureOptions): Promise<boolean>;
+    /**
+     * Verify and parse an incoming event-webhook delivery in one step
+     * (Stripe's constructEvent pattern). Throws InodraWebhookSignatureError
+     * on a bad or expired signature, and a zod error if the body doesn't
+     * look like an Inodra delivery.
+     *
+     * Pair with `matchCatalogEvent`/`parseCatalogEvent` from
+     * `@inodra/sui/events` to narrow the payload to a catalog event type.
+     *
+     * ```ts
+     * const body = await inodra.webhooks.constructEvent({
+     *   payload: rawBody, // exact raw string — do not JSON.parse first
+     *   signature: req.headers["x-inodra-signature"],
+     *   secret: process.env.INODRA_WEBHOOK_SECRET,
+     * });
+     * const swap = parseCatalogEvent(body, "cetus.swap");
+     * ```
+     */
+    constructEvent(options: VerifyWebhookSignatureOptions): Promise<WebhookEventBody>;
+}
+
+/** Per-protocol endpoint overrides (all optional; defaults come from network). */
+interface InodraEndpointOverrides {
+    /** REST base URL, e.g. http://localhost:3000/v1 */
+    rest?: string;
+    /** GraphQL endpoint URL. */
+    graphql?: string;
+    /** host:port for native gRPC transports. */
+    grpc?: string;
+    /** Base URL for gRPC-Web transports. */
+    grpcWeb?: string;
+    /** WS base URL for Warp streams, e.g. ws://localhost:3000/v1 */
+    warpWs?: string;
+}
+interface InodraOptions {
+    /** Credentials: an API key string, {apiKey}, {sessionToken}, or a provider. */
+    auth?: InodraAuth;
+    /** Shorthand for `auth: { apiKey }`. */
+    apiKey?: string;
+    /** Defaults to "mainnet". */
+    network?: InodraNetwork;
+    /** Endpoint overrides for self-hosted / local development. */
+    endpoints?: InodraEndpointOverrides;
+    /** REST retry budget for 429/5xx. Defaults to 2. */
+    maxRetries?: number;
+    /** REST per-request timeout in milliseconds. Defaults to 30000. */
+    timeoutMs?: number;
+    /** Custom fetch implementation. */
+    fetch?: typeof globalThis.fetch;
+    /** Called with rate-limit/credit info after every REST response. */
+    onResponseMeta?: (meta: InodraResponseMeta) => void;
+}
+/**
+ * The Inodra client — one entry point, one credential, every product surface.
+ *
+ * ```ts
+ * const inodra = new Inodra({ network: "mainnet", auth: { apiKey } });
+ *
+ * const balance = await inodra.grpc.core.getBalance({ owner, coinType });
+ * const sub = await inodra.warp.createEventStream({ eventType });
+ * const stream = inodra.warp.connect(sub.id);
+ * ```
+ *
+ * Namespaces are created lazily on first access. The `grpc` client uses a
+ * fetch-based gRPC-Web transport that works in every runtime; on Node.js,
+ * import `Inodra` from `@inodra/sui/node` for native HTTP/2 gRPC instead.
+ *
+ * Bundle note: this entry statically references `@mysten/sui`. Frontend apps
+ * that only need Warp/webhooks and want a Mysten-free bundle should import
+ * from the lean subpaths (`@inodra/sui/warp`, `@inodra/sui/manage`, …).
+ */
+declare class Inodra {
+    readonly network: InodraNetwork;
+    /** The underlying REST transport (shared by all REST namespaces). */
+    readonly http: InodraHttpClient;
+    protected readonly options: InodraOptions;
+    protected readonly auth: InodraAuth;
+    private memo;
+    constructor(options: InodraOptions);
+    /** Rate-limit/credit info from the most recent REST response. */
+    get lastResponseMeta(): InodraResponseMeta | undefined;
+    /**
+     * Sui gRPC client (@mysten/sui) over Inodra's authenticated gateway.
+     * Uses a fetch-based gRPC-Web transport — works in browsers, edge
+     * runtimes, and Node. For native HTTP/2 gRPC on Node, use
+     * `@inodra/sui/node`.
+     */
+    get grpc(): SuiGrpcClient;
+    /** Sui GraphQL client (@mysten/sui) over Inodra's authenticated gateway. */
+    get graphql(): SuiGraphQLClient;
+    /** Warp streams: subscription CRUD + live SSE/WebSocket delivery. */
+    get warp(): WarpNamespace;
+    /** Webhooks: subscription CRUD + delivery signature verification. */
+    get webhooks(): WebhooksNamespace;
+    /** Indexer-backed data: accounts, coins, packages, validators, SuiNS, …. */
+    get data(): DataNamespace;
+    /** Curated protocol event catalog (live view). */
+    get catalog(): CatalogNamespace;
+    /** The authenticated principal: key introspection + usage stats. */
+    get account(): AccountNamespace;
+    /** Reflection-based typed payloads for arbitrary (uncataloged) events. */
+    get events(): EventsNamespace;
+    /** Default endpoints for this client's network. */
+    get endpoints(): (typeof INODRA_ENDPOINTS)[InodraNetwork];
+    protected createGrpcClient(): SuiGrpcClient;
+    protected lazy<T>(key: string, create: () => T): T;
+}
+
+declare class InodraError extends Error {
+    readonly status: number;
+    readonly requestId?: string;
+    readonly body?: unknown;
+    /** Stable machine-readable error code from the API (e.g. "QUOTA_EXCEEDED"). */
+    readonly code?: string;
+    constructor(message: string, options: {
+        status: number;
+        requestId?: string;
+        body?: unknown;
+        code?: string;
+    });
+}
+declare class InodraAuthenticationError extends InodraError {
+    constructor(options: {
+        status: number;
+        requestId?: string;
+        body?: unknown;
+        code?: string;
+        message?: string;
+    });
+}
+declare class InodraRateLimitError extends InodraError {
+    readonly retryAfterSeconds?: number;
+    constructor(options: {
+        status: number;
+        requestId?: string;
+        body?: unknown;
+        code?: string;
+        retryAfterSeconds?: number;
+        message?: string;
+    });
+}
+declare class InodraTimeoutError extends Error {
+    constructor(timeoutMs: number);
+}
+declare class InodraWebhookSignatureError extends Error {
+    constructor();
+}
+
+declare const SDK_VERSION = "0.1.0";
+
+export { AccountNamespace, type CatalogEventMessage, type CatalogEventStream, CatalogNamespace, type ConnectOptions, type ConnectWebSocketOptions, CreateAddressStreamInput, CreateAddressWebhookInput, CreateCoinStreamInput, CreateCoinWebhookInput, CreateEventStreamInput, CreateEventWebhookInput, CreateObjectStreamInput, CreateObjectWebhookInput, CreateStreamResponse, CreateWebhookResponse, DataNamespace, DeleteStreamResponse, DeleteWebhookResponse, EventsNamespace, INODRA_ENDPOINTS, Inodra, InodraAuth, InodraAuthenticationError, type InodraEndpointOverrides, InodraError, InodraHttpClient, InodraNetwork, type InodraOptions, InodraRateLimitError, InodraResponseMeta, InodraTimeoutError, InodraWebhookSignatureError, ListStreamsResponse, ListWebhooksResponse, SDK_VERSION, type StreamCatalogEventOptions, UpdateStreamInput, UpdateStreamResponse, UpdateWebhookInput, UpdateWebhookResponse, VerifyWebhookSignatureOptions, WarpNamespace, WarpSseStream, WarpSseStreamOptions, WarpStream, WarpWebSocketStream, WarpWebSocketStreamOptions, Webhook, WebhooksNamespace };

package/dist/index.js

@@ -0,0 +1,59 @@
+import {
+  AccountNamespace,
+  CatalogNamespace,
+  DataNamespace,
+  EventsNamespace,
+  Inodra,
+  WarpNamespace,
+  WebhooksNamespace,
+  paginate
+} from "./chunk-OGMBYWTG.js";
+import {
+  verifyWebhookSignature
+} from "./chunk-4HKKW5QN.js";
+import "./chunk-M3M2L6BW.js";
+import "./chunk-74XGJJJI.js";
+import {
+  WarpSseStream,
+  WarpWebSocketStream,
+  iterateStream
+} from "./chunk-ZSW3EWGF.js";
+import {
+  InodraAuthenticationError,
+  InodraError,
+  InodraHttpClient,
+  InodraManagementClient,
+  InodraRateLimitError,
+  InodraTimeoutError,
+  InodraWebhookSignatureError
+} from "./chunk-NSXRC5XW.js";
+import {
+  INODRA_ENDPOINTS,
+  SDK_VERSION,
+  resolveAuth
+} from "./chunk-U6D5LGNF.js";
+export {
+  AccountNamespace,
+  CatalogNamespace,
+  DataNamespace,
+  EventsNamespace,
+  INODRA_ENDPOINTS,
+  Inodra,
+  InodraAuthenticationError,
+  InodraError,
+  InodraHttpClient,
+  InodraManagementClient,
+  InodraRateLimitError,
+  InodraTimeoutError,
+  InodraWebhookSignatureError,
+  SDK_VERSION,
+  WarpNamespace,
+  WarpSseStream,
+  WarpWebSocketStream,
+  WebhooksNamespace,
+  iterateStream,
+  paginate,
+  resolveAuth,
+  verifyWebhookSignature
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}