@dvina/sdk 4.1.58 → 4.1.64

package/dist/error-CsVoUTY8.d.cts

@@ -1,95 +0,0 @@
-/**
- * Base error class for all Dvina SDK errors.
- */
-declare class DvinaError extends Error {
-    /** The original error, if any */
-    readonly cause?: Error;
-    constructor(message: string, cause?: Error);
-}
-/**
- * Error thrown when the GraphQL response contains errors.
- */
-declare class DvinaGraphQLError extends DvinaError {
-    /** The raw GraphQL errors array */
-    readonly errors: readonly GraphQLErrorEntry[];
-    /** The query that caused the error (for debugging) */
-    readonly query?: string;
-    /** The variables that were passed */
-    readonly variables?: Record<string, unknown>;
-    constructor(errors: readonly GraphQLErrorEntry[], query?: string, variables?: Record<string, unknown>);
-}
-/**
- * Error thrown on network failures (connection refused, timeout, etc.)
- */
-declare class DvinaNetworkError extends DvinaError {
-    /** HTTP status code, if available */
-    readonly status?: number;
-    constructor(message: string, status?: number, cause?: Error);
-}
-/**
- * Error thrown when authentication fails (401/403).
- */
-declare class DvinaAuthenticationError extends DvinaError {
-    /** The token that was used when the auth error occurred (for stale-token detection). */
-    readonly failedToken?: string;
-    constructor(message?: string, failedTokenOrCause?: string | Error, cause?: Error);
-}
-/**
- * Known GraphQL error codes returned by the Dvina API in `extensions.code`.
- * Used for programmatic matching in SDK error detection.
- */
-declare const GRAPHQL_ERROR_CODES: {
-    readonly SESSION_TOKEN_LIMIT_REACHED: "SESSION_TOKEN_LIMIT_REACHED";
-    readonly STORAGE_LIMIT_REACHED: "STORAGE_LIMIT_REACHED";
-    readonly DEEP_ANALYSIS_LIMIT_EXCEEDED: "DEEP_ANALYSIS_LIMIT_EXCEEDED";
-    readonly PLAN_DETAIL_RESTRICTION: "PLAN_DETAIL_RESTRICTION";
-    readonly RESOURCE_NOT_FOUND: "RESOURCE_NOT_FOUND";
-};
-/**
- * Base class for plan/billing restriction errors.
- * Thrown when the workspace exceeds a plan limit (storage, capabilities, deep analysis).
- *
- * Consumers can `catch (e) { if (e instanceof DvinaPlanRestrictionError) showUpgradeDialog(); }`
- */
-declare class DvinaPlanRestrictionError extends DvinaGraphQLError {
-    /** The specific restriction code (e.g. 'PLAN_DETAIL_RESTRICTION') */
-    readonly restrictionCode: string;
-    constructor(errors: readonly GraphQLErrorEntry[], restrictionCode: string, query?: string, variables?: Record<string, unknown>);
-}
-/**
- * Error thrown when the chat session token limit is reached (SESSION_TOKEN_LIMIT_REACHED).
- * Distinct from inference quota — this is a per-session GraphQL limit.
- */
-declare class DvinaTokenLimitError extends DvinaGraphQLError {
-    constructor(errors: readonly GraphQLErrorEntry[], query?: string, variables?: Record<string, unknown>);
-}
-/**
- * Error thrown when a requested resource is not found (RESOURCE_NOT_FOUND).
- */
-declare class DvinaNotFoundError extends DvinaGraphQLError {
-    constructor(errors: readonly GraphQLErrorEntry[], query?: string, variables?: Record<string, unknown>);
-}
-/**
- * Extract the first extension code from a list of GraphQL errors (normalized to uppercase).
- * Returns `undefined` if no code is present.
- */
-declare function extractErrorCode(errors: readonly GraphQLErrorEntry[]): string | undefined;
-/**
- * Create the appropriate `DvinaGraphQLError` subclass for the given errors,
- * or return a generic `DvinaGraphQLError` if no specific match is found.
- */
-declare function createGraphQLError(errors: readonly GraphQLErrorEntry[], query?: string, variables?: Record<string, unknown>): DvinaGraphQLError;
-/**
- * Shape of a single GraphQL error in the response.
- */
-interface GraphQLErrorEntry {
-    message: string;
-    locations?: readonly {
-        line: number;
-        column: number;
-    }[];
-    path?: readonly (string | number)[];
-    extensions?: Record<string, unknown>;
-}
-
-export { DvinaError as D, GRAPHQL_ERROR_CODES as G, DvinaAuthenticationError as a, DvinaGraphQLError as b, DvinaNetworkError as c, DvinaNotFoundError as d, DvinaPlanRestrictionError as e, DvinaTokenLimitError as f, type GraphQLErrorEntry as g, createGraphQLError as h, extractErrorCode as i };

package/dist/index-D_Z25Pa1.d.cts

@@ -1,79 +0,0 @@
-import { b as DvinaRequest, c as DvinaSubscribe, P as PageInfoData, C as ConnectionVariables, F as FetchOptions } from './types-Chg8ASmf.cjs';
-import { S as SyncEngine } from './sync-engine-gpxyhQBl.cjs';
-
-/**
- * Base class that holds the transport functions.
- * Every generated model, connection, query, and the root SDK class extend this.
- *
- * Operation classes use `_syncEngine` for queries/mutations/watch.
- * Subscription classes use `_subscribe` for WebSocket streaming.
- * Model classes use `_request` for compatibility (lazy fetch).
- */
-declare class Request {
-    protected _request: DvinaRequest;
-    protected _syncEngine?: SyncEngine;
-    protected _subscribe?: DvinaSubscribe;
-    protected _baseUrl?: string;
-    constructor(request: DvinaRequest, syncEngine?: SyncEngine, subscribe?: DvinaSubscribe, baseUrl?: string);
-}
-
-/**
- * Default connection variables when paginating.
- * Ensures `first` or `last` is set when a cursor is provided.
- */
-declare function defaultConnection<V extends ConnectionVariables>(variables: V): V;
-/**
- * PageInfo model following the Relay spec.
- */
-declare class PageInfo {
-    hasNextPage: boolean;
-    hasPreviousPage: boolean;
-    startCursor?: string | null;
-    endCursor?: string | null;
-    constructor(data: PageInfoData);
-}
-/**
- * Abstract base class for connection types.
- * Holds nodes and page info, used for type checking.
- */
-declare abstract class AbstractConnection<Node> extends Request {
-    pageInfo: PageInfo;
-    nodes: Node[];
-    totalCount?: number;
-    constructor(request: DvinaRequest);
-}
-/**
- * Concrete connection class with pagination helpers.
- * Generated connection subclasses extend this.
- *
- * The `_fetch` closure is created by the query class and allows re-fetching
- * with different pagination variables.
- */
-declare class Connection<Node> extends AbstractConnection<Node> {
-    private _fetch;
-    constructor(request: DvinaRequest, fetch: (variables?: ConnectionVariables, options?: FetchOptions) => Promise<Connection<Node> | undefined>, nodes: Node[], pageInfo: PageInfo, totalCount?: number);
-    /**
-     * Fetch the next page and append nodes.
-     * Mutates this connection instance in place (nodes are appended, pageInfo updated).
-     */
-    fetchNext(options?: FetchOptions): Promise<this>;
-    /**
-     * Fetch the previous page and prepend nodes.
-     * Mutates this connection instance in place (nodes are prepended, pageInfo updated).
-     */
-    fetchPrevious(options?: FetchOptions): Promise<this>;
-}
-
-/**
- * Extract all nodes from a connection.
- */
-declare function extractNodes<T>(connection: Connection<T>): T[];
-/**
- * Merge two connections into a new connection. Appends the second connection's
- * nodes after the first's. Uses the second connection's end cursor and hasNextPage.
- *
- * Neither input connection is modified.
- */
-declare function mergeConnections<T>(first: Connection<T>, second: Connection<T>): Connection<T>;
-
-export { AbstractConnection as A, Connection as C, PageInfo as P, Request as R, defaultConnection as d, extractNodes as e, mergeConnections as m };