altair-graphql-core 5.0.8 → 5.0.12

package/build/cjs/config.d.ts

@@ -0,0 +1,159 @@
+import { SubscriptionProviderIds } from './subscriptions';
+import { IDictionary } from './types/shared';
+import { IInitialEnvironments } from './types/state/environments.interfaces';
+import { HttpVerb } from './types/state/query.interfaces';
+import { SettingsState } from './types/state/settings.interfaces';
+export interface AltairWindowOptions {
+    /**
+     * Initial name of the window
+     */
+    initialName?: string;
+    /**
+     * URL to set as the server endpoint
+     */
+    endpointURL?: string;
+    /**
+     * URL to set as the subscription endpoint. This can be relative or absolute.
+     */
+    subscriptionsEndpoint?: string;
+    /**
+     * URL protocol for the subscription endpoint. This is used if the specified subscriptions endpoint is relative.
+     * e.g. wss
+     */
+    subscriptionsProtocol?: string;
+    /**
+     * Initial query to be added
+     */
+    initialQuery?: string;
+    /**
+     * Initial variables to be added
+     */
+    initialVariables?: string;
+    /**
+     * Initial pre-request script to be added
+     */
+    initialPreRequestScript?: string;
+    /**
+     * Initial post-request script to be added
+     */
+    initialPostRequestScript?: string;
+    /**
+     * Initial headers object to be added
+     * @example
+     * {
+     *  'X-GraphQL-Token': 'asd7-237s-2bdk-nsdk4'
+     * }
+     */
+    initialHeaders?: IDictionary;
+    /**
+     * Initial subscriptions provider
+     *
+     * @default "websocket"
+     */
+    initialSubscriptionsProvider?: SubscriptionProviderIds;
+    /**
+     * Initial subscriptions connection params
+     */
+    initialSubscriptionsPayload?: IDictionary;
+    /**
+     * HTTP method to use for making requests
+     */
+    initialHttpMethod?: HttpVerb;
+}
+export interface AltairConfigOptions extends AltairWindowOptions {
+    /**
+     * Initial Environments to be added
+     * @example
+     * {
+     *   base: {
+     *     title: 'Environment',
+     *     variables: {}
+     *   },
+     *   subEnvironments: [
+     *     {
+     *       title: 'sub-1',
+     *       variables: {}
+     *     }
+     *   ]
+     * }
+     */
+    initialEnvironments?: IInitialEnvironments;
+    /**
+     * Namespace for storing the data for the altair instance.
+     * Use this when you have multiple altair instances running on the same domain.
+     * @example
+     * instanceStorageNamespace: 'altair_dev_'
+     */
+    instanceStorageNamespace?: string;
+    /**
+     * Initial app settings to use
+     */
+    initialSettings?: Partial<SettingsState>;
+    /**
+     * Indicates if the state should be preserved for subsequent app loads
+     *
+     * @default true
+     */
+    preserveState?: boolean;
+    /**
+     * List of options for windows to be loaded
+     */
+    initialWindows?: AltairWindowOptions[];
+}
+export declare class AltairConfig {
+    donation: {
+        url: string;
+        action_count_threshold: number;
+    };
+    ga: string;
+    add_query_depth_limit: number;
+    tab_size: number;
+    max_windows: number;
+    default_language: string;
+    languages: {
+        'en-US': string;
+        'fr-FR': string;
+        'es-ES': string;
+        'cs-CZ': string;
+        'de-DE': string;
+        'pt-BR': string;
+        'ru-RU': string;
+        'uk-UA': string;
+        'zh-CN': string;
+        'ja-JP': string;
+        'sr-SP': string;
+        'it-IT': string;
+        'pl-PL': string;
+        'ko-KR': string;
+        'ro-RO': string;
+        'vi-VN': string;
+    };
+    query_history_depth: number;
+    disableLineNumbers: boolean;
+    defaultTheme: string;
+    themes: string[];
+    isTranslateMode: any;
+    isWebApp: any;
+    initialData: {
+        url: string;
+        subscriptionsEndpoint: string;
+        subscriptionsProtocol: string;
+        query: string;
+        variables: string;
+        headers: IDictionary<any>;
+        environments: IInitialEnvironments;
+        preRequestScript: string;
+        postRequestScript: string;
+        instanceStorageNamespace: string;
+        settings: Partial<SettingsState> | undefined;
+        initialSubscriptionsProvider: SubscriptionProviderIds | undefined;
+        initialSubscriptionsPayload: IDictionary<any>;
+        initialHttpMethod: "POST" | "GET" | "PUT" | "DELETE";
+        preserveState: boolean;
+        windows: AltairWindowOptions[];
+    };
+    constructor({ endpointURL, subscriptionsEndpoint, subscriptionsProtocol, initialQuery, initialHeaders, initialEnvironments, initialVariables, initialPreRequestScript, initialPostRequestScript, instanceStorageNamespace, initialSettings, initialSubscriptionsProvider, initialSubscriptionsPayload, initialHttpMethod, preserveState, initialWindows, }?: AltairConfigOptions);
+}
+export declare const setAltairConfig: (_config: AltairConfig) => void;
+export declare const getAltairConfig: () => AltairConfig;
+//# sourceMappingURL=config.d.ts.map

package/build/cjs/config.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAltairConfig = exports.setAltairConfig = exports.AltairConfig = void 0;
+const subscriptions_1 = require("./subscriptions");
+const is_electron_1 = __importDefault(require("./utils/is_electron"));
+const isTranslateMode = window.__ALTAIR_TRANSLATE__;
+class AltairConfig {
+    constructor({ endpointURL, subscriptionsEndpoint, subscriptionsProtocol, initialQuery, initialHeaders, initialEnvironments, initialVariables, initialPreRequestScript, initialPostRequestScript = '', instanceStorageNamespace, initialSettings, initialSubscriptionsProvider = subscriptions_1.WEBSOCKET_PROVIDER_ID, initialSubscriptionsPayload = {}, initialHttpMethod = 'POST', preserveState = true, initialWindows = [], } = {}) {
+        this.donation = {
+            url: 'https://opencollective.com/altair/donate',
+            action_count_threshold: 50,
+        };
+        this.ga = 'UA-41432833-6';
+        this.add_query_depth_limit = 3;
+        this.tab_size = 2;
+        this.max_windows = is_electron_1.default ? 50 : 15;
+        this.default_language = isTranslateMode ? 'ach-UG' : 'en-US';
+        this.languages = {
+            'en-US': 'English',
+            'fr-FR': 'French',
+            'es-ES': 'Español',
+            'cs-CZ': 'Czech',
+            'de-DE': 'German',
+            'pt-BR': 'Brazilian',
+            'ru-RU': 'Russian',
+            'uk-UA': 'Ukrainian',
+            'zh-CN': 'Chinese Simplified',
+            'ja-JP': 'Japanese',
+            'sr-SP': 'Serbian',
+            'it-IT': 'Italian',
+            'pl-PL': 'Polish',
+            'ko-KR': 'Korean',
+            'ro-RO': 'Romanian',
+            'vi-VN': 'Vietnamese',
+        };
+        this.query_history_depth = is_electron_1.default ? 100 : 15;
+        this.disableLineNumbers = false;
+        this.defaultTheme = 'system';
+        this.themes = ['light', 'dark', 'dracula', 'system'];
+        this.isTranslateMode = isTranslateMode;
+        this.isWebApp = window.__ALTAIR_WEB_APP__;
+        this.initialData = {
+            url: '',
+            subscriptionsEndpoint: '',
+            subscriptionsProtocol: '',
+            query: '',
+            variables: '',
+            // Force type of header, since initial value inference is wrong
+            headers: null,
+            environments: {},
+            preRequestScript: '',
+            postRequestScript: '',
+            instanceStorageNamespace: 'altair_',
+            settings: undefined,
+            initialSubscriptionsProvider: undefined,
+            initialSubscriptionsPayload: {},
+            initialHttpMethod: 'POST',
+            preserveState: true,
+            windows: [],
+        };
+        this.initialData.url =
+            window.__ALTAIR_ENDPOINT_URL__ || endpointURL || '';
+        this.initialData.subscriptionsEndpoint =
+            window.__ALTAIR_SUBSCRIPTIONS_ENDPOINT__ ||
+                subscriptionsEndpoint ||
+                '';
+        this.initialData.subscriptionsProtocol = subscriptionsProtocol || '';
+        this.initialData.query =
+            window.__ALTAIR_INITIAL_QUERY__ || initialQuery || '';
+        this.initialData.variables =
+            window.__ALTAIR_INITIAL_VARIABLES__ || initialVariables || '';
+        this.initialData.headers =
+            window.__ALTAIR_INITIAL_HEADERS__ || initialHeaders || '';
+        this.initialData.environments = initialEnvironments || {};
+        this.initialData.preRequestScript =
+            window.__ALTAIR_INITIAL_PRE_REQUEST_SCRIPT__ ||
+                initialPreRequestScript ||
+                '';
+        this.initialData.postRequestScript = initialPostRequestScript;
+        this.initialData.instanceStorageNamespace =
+            window.__ALTAIR_INSTANCE_STORAGE_NAMESPACE__ ||
+                instanceStorageNamespace ||
+                'altair_';
+        this.initialData.settings = initialSettings;
+        this.initialData.initialSubscriptionsProvider =
+            initialSubscriptionsProvider;
+        this.initialData.initialSubscriptionsPayload = initialSubscriptionsPayload;
+        this.initialData.initialHttpMethod = initialHttpMethod;
+        this.initialData.preserveState = preserveState;
+        this.initialData.windows = initialWindows;
+    }
+}
+exports.AltairConfig = AltairConfig;
+let config = new AltairConfig();
+const setAltairConfig = (_config) => {
+    config = _config;
+};
+exports.setAltairConfig = setAltairConfig;
+const getAltairConfig = () => {
+    return config;
+};
+exports.getAltairConfig = getAltairConfig;
+window.getAltairConfig = exports.getAltairConfig;

package/build/cjs/index.d.ts

@@ -0,0 +1,3 @@
+import { PluginBase, PluginConstructor } from './plugin/base';
+export declare const registerPluginClass: <T extends PluginBase>(pluginClassName: string, pluginClass: PluginConstructor<T>) => void;
+//# sourceMappingURL=index.d.ts.map

package/build/cjs/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPluginClass = void 0;
+const registerPluginClass = (pluginClassName, pluginClass) => {
+    window['AltairGraphQL'].plugins[pluginClassName] = pluginClass;
+};
+exports.registerPluginClass = registerPluginClass;

package/build/cjs/plugin/base.d.ts

@@ -0,0 +1,11 @@
+import { PluginContext } from './context/context.interface';
+export declare abstract class PluginBase {
+    protected ctx: PluginContext;
+    constructor(ctx: PluginContext);
+    abstract initialize(ctx: PluginContext): void;
+    abstract destroy(): void;
+}
+export interface PluginConstructor<T extends PluginBase = PluginBase> {
+    new (): T;
+}
+//# sourceMappingURL=base.d.ts.map

package/build/cjs/plugin/base.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginBase = void 0;
+class PluginBase {
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+}
+exports.PluginBase = PluginBase;

package/build/cjs/plugin/context/context.interface.d.ts

@@ -0,0 +1,78 @@
+import { SubscriptionProviderData } from '../../subscriptions';
+import { ICustomTheme } from '../../theme';
+import { ExportWindowState } from '../../types/state/window.interfaces';
+import { PluginEvent, PluginEventCallback } from '../event/event.interfaces';
+import { AltairPanel, AltairPanelLocation } from '../panel';
+import { AltairPlugin } from '../plugin.interfaces';
+import { AltairUiAction, AltairUiActionLocation } from '../ui-action';
+export interface CreatePanelOptions {
+    title?: string;
+    location?: AltairPanelLocation;
+}
+export interface CreateActionOptions {
+    title: string;
+    location?: AltairUiActionLocation;
+    execute: (data: PluginWindowState) => void;
+}
+export interface PluginWindowState extends ExportWindowState {
+    windowId: string;
+    sdl: string;
+    queryResult: string;
+    requestStartTime: number;
+    requestEndTime: number;
+    responseTime: number;
+    responseStatus: number;
+}
+export interface PluginContext {
+    app: {
+        /**
+         * Returns an allowed set of data from the state visible to plugins
+         *
+         * Since it is a method, the state can be generated when called.
+         * So we can ensure uniqueness of the state, as well as avoid passing values by references.
+         */
+        getWindowState(windowId: string): Promise<PluginWindowState | undefined>;
+        getCurrentWindowState(): Promise<PluginWindowState | undefined>;
+        /**
+         * panel has two locations: sidebar, header
+         *
+         * Each call creates a new panel. Instead, plugin should create panel only once (@initialize)
+         * Panel can be destroyed when the plugin is unused.
+         *
+         * returns panel instance (includes destroy() method)
+         */
+        createPanel(element: HTMLElement, options?: CreatePanelOptions): AltairPanel;
+        destroyPanel(panel: AltairPanel): void;
+        /**
+         * action has 1 location for now: resultpane
+         *
+         * Each call creates a new action. Instead, plugins should create action once, when needed
+         * Action can be destroyed when the plugin decides to.
+         *
+         * returns action instance (includes destroy() method)
+         */
+        createAction(options: CreateActionOptions): AltairUiAction;
+        destroyAction(uiAction: AltairUiAction): void;
+        isElectron(): boolean;
+        createWindow(data: ExportWindowState): void;
+        setQuery(windowId: string, query: string): void;
+        setVariables(windowId: string, variables: string): void;
+        setEndpoint(windowId: string, url: string): void;
+        addSubscriptionProvider(providerData: SubscriptionProviderData): void;
+        executeCommand(): void;
+    };
+    events: {
+        on<E extends PluginEvent>(event: E, callback: PluginEventCallback<E>): {
+            unsubscribe: () => void;
+        };
+        off(): void;
+    };
+    theme: {
+        add(name: string, theme: ICustomTheme): void;
+        enable(name: string, darkMode?: boolean): Promise<void>;
+    };
+}
+export interface PluginContextGenerator {
+    createContext(pluginName: string, plugin: AltairPlugin): PluginContext;
+}
+//# sourceMappingURL=context.interface.d.ts.map

package/build/cjs/plugin/context/context.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/plugin/event/event.interfaces.d.ts

@@ -0,0 +1,30 @@
+export interface PluginEventPayloadMap {
+    'app-ready': boolean;
+    'current-window.change': {
+        windowId: string;
+    };
+    'query.change': {
+        windowId: string;
+        data: string;
+    };
+    'query-result.change': {
+        windowId: string;
+        data: any;
+    };
+    'query-result-meta.change': {
+        windowId: string;
+        data: {
+            requestStartTime: number;
+            requestEndTime: number;
+            responseTime: number;
+            responseStatus: number;
+        };
+    };
+    'sdl.change': {
+        windowId: string;
+        data: string;
+    };
+}
+export type PluginEvent = keyof PluginEventPayloadMap;
+export type PluginEventCallback<T extends PluginEvent> = (payload: PluginEventPayloadMap[T]) => void;
+//# sourceMappingURL=event.interfaces.d.ts.map

package/build/cjs/plugin/event/event.interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/plugin/panel.d.ts

@@ -0,0 +1,18 @@
+export declare enum AltairPanelLocation {
+    HEADER = "header",
+    SIDEBAR = "sidebar",
+    RESULT_PANE_BOTTOM = "result_pane_bottom"
+}
+/**
+ * Used for dynamic panel elements. Can also be used for angular components in the future.
+ */
+export declare class AltairPanel {
+    title: string;
+    element: HTMLElement;
+    location: AltairPanelLocation;
+    id: string;
+    isActive: boolean;
+    constructor(title: string, element: HTMLElement, location: AltairPanelLocation);
+    destroy(): void;
+}
+//# sourceMappingURL=panel.d.ts.map

package/build/cjs/plugin/panel.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltairPanel = exports.AltairPanelLocation = void 0;
+const uuid_1 = require("uuid");
+var AltairPanelLocation;
+(function (AltairPanelLocation) {
+    AltairPanelLocation["HEADER"] = "header";
+    AltairPanelLocation["SIDEBAR"] = "sidebar";
+    AltairPanelLocation["RESULT_PANE_BOTTOM"] = "result_pane_bottom";
+})(AltairPanelLocation = exports.AltairPanelLocation || (exports.AltairPanelLocation = {}));
+/**
+ * Used for dynamic panel elements. Can also be used for angular components in the future.
+ */
+class AltairPanel {
+    constructor(title, element, location) {
+        this.title = title;
+        this.element = element;
+        this.location = location;
+        this.id = (0, uuid_1.v4)();
+        this.isActive = false;
+    }
+    destroy() {
+        this.element = null;
+    }
+}
+exports.AltairPanel = AltairPanel;

package/build/cjs/plugin/plugin.interfaces.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Defines the repository of the plugin.
+ * Used to know where to get the plugin from.
+ */
+export declare enum PluginSource {
+    NPM = "npm",
+    GITHUB = "github",
+    URL = "url"
+}
+/**
+ * Specifies the type of the plugin.
+ * Determines how the plugin would interact with Altair.
+ */
+export declare enum PluginType {
+    HEADER = "header",
+    SIDEBAR = "sidebar",
+    ACTION_BUTTON = "action_button"
+}
+/**
+ * Specifies the capabilities (functionalities) available to the plugin.
+ * In the future, this would be used to request the necessary permissions from the user.
+ */
+export type PluginCapabilities = 'query:read' | 'query:write' | 'header:read' | 'header:write' | 'environment:read' | 'environment:write';
+/**
+ * Plugin Manifest Structure
+ */
+export interface PluginManifest {
+    manifest_version: number;
+    name: string;
+    display_name: string;
+    version: string;
+    description: string;
+    author_email?: string;
+    author?: string;
+    type?: PluginType;
+    plugin_class?: string;
+    scripts: string[];
+    styles?: string[];
+    capabilities?: PluginCapabilities[];
+}
+export interface AltairPlugin {
+    name: string;
+    display_name: string;
+    capabilities: PluginCapabilities[];
+    type?: PluginType;
+    plugin_class?: string;
+    manifest: PluginManifest;
+}
+export declare const createPlugin: (name: string, manifest: PluginManifest) => AltairPlugin;
+export interface RemotePluginListItem {
+    name: string;
+    version: string;
+    description: string;
+    author: string | null;
+    created_at: number;
+    updated_at: number;
+    homepage: string | null;
+    summary: string | null;
+    manifest: PluginManifest;
+}
+export interface RemotePluginListResponse {
+    page: number;
+    total: number;
+    items: RemotePluginListItem[];
+}
+//# sourceMappingURL=plugin.interfaces.d.ts.map

package/build/cjs/plugin/plugin.interfaces.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPlugin = exports.PluginType = exports.PluginSource = void 0;
+/**
+ * Defines the repository of the plugin.
+ * Used to know where to get the plugin from.
+ */
+var PluginSource;
+(function (PluginSource) {
+    PluginSource["NPM"] = "npm";
+    PluginSource["GITHUB"] = "github";
+    PluginSource["URL"] = "url";
+})(PluginSource = exports.PluginSource || (exports.PluginSource = {}));
+/**
+ * Specifies the type of the plugin.
+ * Determines how the plugin would interact with Altair.
+ */
+var PluginType;
+(function (PluginType) {
+    PluginType["HEADER"] = "header";
+    PluginType["SIDEBAR"] = "sidebar";
+    PluginType["ACTION_BUTTON"] = "action_button";
+})(PluginType = exports.PluginType || (exports.PluginType = {}));
+const createPlugin = (name, manifest) => {
+    return {
+        name,
+        manifest,
+        type: manifest.type,
+        display_name: manifest.display_name || name,
+        plugin_class: manifest.plugin_class,
+        capabilities: Array.from(new Set([
+            ...(manifest.capabilities || []),
+            ...['query:read', 'query:write'],
+        ])),
+    };
+};
+exports.createPlugin = createPlugin;

package/build/cjs/plugin/ui-action.d.ts

@@ -0,0 +1,12 @@
+export declare enum AltairUiActionLocation {
+    RESULT_PANE = "result_pane"
+}
+export declare class AltairUiAction {
+    title: string;
+    location: AltairUiActionLocation;
+    callback: () => void;
+    id: string;
+    constructor(title: string, location: AltairUiActionLocation, callback: () => void);
+    execute(): void;
+}
+//# sourceMappingURL=ui-action.d.ts.map

package/build/cjs/plugin/ui-action.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltairUiAction = exports.AltairUiActionLocation = void 0;
+const uuid_1 = require("uuid");
+var AltairUiActionLocation;
+(function (AltairUiActionLocation) {
+    AltairUiActionLocation["RESULT_PANE"] = "result_pane";
+})(AltairUiActionLocation = exports.AltairUiActionLocation || (exports.AltairUiActionLocation = {}));
+class AltairUiAction {
+    constructor(title, location, callback) {
+        this.title = title;
+        this.location = location;
+        this.callback = callback;
+        this.id = (0, uuid_1.v4)();
+    }
+    execute() {
+        this.callback();
+    }
+}
+exports.AltairUiAction = AltairUiAction;

package/build/cjs/subscriptions/index.d.ts

@@ -0,0 +1,20 @@
+import { SubscriptionProviderConstructor } from './subscription-provider';
+export declare const WEBSOCKET_PROVIDER_ID = "websocket";
+export declare const GRAPHQL_WS_PROVIDER_ID = "graphql-ws";
+export declare const APP_SYNC_PROVIDER_ID = "app-sync";
+export declare const ACTION_CABLE_PROVIDER_ID = "action-cable";
+export declare const GRAPHQL_SSE_ID = "graphql-sse";
+export declare const SUBSCRIPTION_PROVIDER_IDS: {
+    readonly WEBSOCKET: "websocket";
+    readonly GRAPHQL_WS: "graphql-ws";
+    readonly APP_SYNC: "app-sync";
+    readonly ACTION_CABLE: "action-cable";
+    readonly GRAPHQL_SSE: "graphql-sse";
+};
+export type SubscriptionProviderIds = typeof SUBSCRIPTION_PROVIDER_IDS[keyof typeof SUBSCRIPTION_PROVIDER_IDS];
+export interface SubscriptionProviderData {
+    id: string;
+    getProviderClass: () => Promise<SubscriptionProviderConstructor>;
+    copyTag?: string;
+}
+//# sourceMappingURL=index.d.ts.map

package/build/cjs/subscriptions/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUBSCRIPTION_PROVIDER_IDS = exports.GRAPHQL_SSE_ID = exports.ACTION_CABLE_PROVIDER_ID = exports.APP_SYNC_PROVIDER_ID = exports.GRAPHQL_WS_PROVIDER_ID = exports.WEBSOCKET_PROVIDER_ID = void 0;
+exports.WEBSOCKET_PROVIDER_ID = 'websocket';
+exports.GRAPHQL_WS_PROVIDER_ID = 'graphql-ws';
+exports.APP_SYNC_PROVIDER_ID = 'app-sync';
+exports.ACTION_CABLE_PROVIDER_ID = 'action-cable';
+exports.GRAPHQL_SSE_ID = 'graphql-sse';
+exports.SUBSCRIPTION_PROVIDER_IDS = {
+    WEBSOCKET: exports.WEBSOCKET_PROVIDER_ID,
+    GRAPHQL_WS: exports.GRAPHQL_WS_PROVIDER_ID,
+    APP_SYNC: exports.APP_SYNC_PROVIDER_ID,
+    ACTION_CABLE: exports.ACTION_CABLE_PROVIDER_ID,
+    GRAPHQL_SSE: exports.GRAPHQL_SSE_ID,
+};

package/build/cjs/subscriptions/providers/action-cable.d.ts

@@ -0,0 +1,9 @@
+import { SubscriptionProvider, SubscriptionProviderExecuteOptions } from '../subscription-provider';
+import { Observable } from 'rxjs';
+export declare class ActionCableSubscriptionProvider extends SubscriptionProvider {
+    subscription?: any;
+    channel?: string;
+    execute(options: SubscriptionProviderExecuteOptions): Observable<unknown>;
+    close(): void;
+}
+//# sourceMappingURL=action-cable.d.ts.map