@google/jules-merge 0.0.1

package/dist/core/src/client.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { JulesClient, JulesOptions, SessionConfig, SourceManager, AutomatedSession, SessionClient, SessionResource, StorageFactory } from './types.js';
+import { SessionCursor, ListSessionsOptions } from './sessions.js';
+import { Platform } from './platform/types.js';
+import { SessionStorage } from './storage/types.js';
+import { JulesQuery, JulesDomain, QueryResult, SyncOptions, SyncStats } from './types.js';
+/**
+ * The fully resolved internal configuration for the SDK.
+ * @internal
+ */
+export type InternalConfig = {
+    pollingIntervalMs: number;
+    requestTimeoutMs: number;
+};
+/**
+ * Implementation of the main JulesClient interface.
+ * This class acts as the central hub for creating and managing sessions,
+ * as well as accessing other resources like sources.
+ */
+export declare class JulesClientImpl implements JulesClient {
+    /**
+     * Manages source connections (e.g., GitHub repositories).
+     */
+    sources: SourceManager;
+    readonly storage: SessionStorage;
+    private apiClient;
+    private config;
+    private options;
+    private storageFactory;
+    private platform;
+    /**
+     * Lock to prevent concurrent sync operations.
+     * Using a simple boolean for in-process locking.
+     */
+    private syncInProgress;
+    /**
+     * Creates a new instance of the JulesClient.
+     *
+     * @param options Configuration options for the client.
+     * @param defaultStorageFactory Factory for creating storage instances.
+     * @param defaultPlatform Platform-specific implementation.
+     */
+    constructor(options: JulesOptions | undefined, defaultStorageFactory: StorageFactory, defaultPlatform: Platform);
+    /**
+     * Fluent API for rich local querying across sessions and activities.
+     * This method uses the modular query engine internally.
+     */
+    select<T extends JulesDomain>(query: JulesQuery<T>): Promise<QueryResult<T>[]>;
+    /**
+     * Synchronizes local state with the server.
+     * Logic:
+     * 1. Find High-Water Mark (newest local record).
+     * 2. Stream latest sessions from API.
+     * 3. Terminate stream early if 'incremental' and High-Water Mark is hit.
+     * 4. Throttled hydration of activities if depth is 'activities'.
+     */
+    sync(options?: SyncOptions): Promise<SyncStats>;
+    private getCheckpointPath;
+    private loadCheckpoint;
+    private saveCheckpoint;
+    private clearCheckpoint;
+    private _getHighWaterMark;
+    /**
+     * Helper to resolve environment variables with support for frontend prefixes.
+     */
+    private getEnv;
+    /**
+     * Creates a new Jules client instance with updated configuration.
+     * This is an immutable operation; the original client instance remains unchanged.
+     *
+     * @param options The new configuration options to merge with the existing ones.
+     * @returns A new JulesClient instance with the updated configuration.
+     */
+    with(options: JulesOptions): JulesClient;
+    /**
+     * Connects to the Jules service with the provided configuration.
+     * Acts as a factory method for creating a new client instance.
+     *
+     * @param options Configuration options for the client.
+     * @returns A new JulesClient instance.
+     */
+    connect(options: JulesOptions): JulesClient;
+    /**
+     * Retrieves a session resource using the "Iceberg" caching strategy.
+     * * - **Tier 3 (Frozen):** > 30 days old. Returns from cache immediately.
+     * - **Tier 2 (Warm):** Terminal state + Verified < 24h ago. Returns from cache.
+     * - **Tier 1 (Hot):** Active or Stale. Fetches from network, updates cache, returns.
+     */
+    getSessionResource(id: string): Promise<SessionResource>;
+    /**
+     * Lists sessions with a fluent, pagination-friendly API.
+     * @param options Configuration for pagination (pageSize, limit, pageToken)
+     * @returns A SessionCursor that can be awaited (first page) or iterated (all pages).
+     */
+    sessions(options?: ListSessionsOptions): SessionCursor;
+    all<T>(items: T[], mapper: (item: T) => SessionConfig | Promise<SessionConfig>, options?: {
+        concurrency?: number;
+        stopOnError?: boolean;
+        delayMs?: number;
+    }): Promise<AutomatedSession[]>;
+    private _prepareSessionCreation;
+    /**
+     * Executes a task in automated mode.
+     * This is a high-level abstraction for "fire-and-forget" tasks.
+     *
+     * **Side Effects:**
+     * - Creates a new session on the Jules API (`POST /sessions`).
+     * - Initiates background polling for activity updates.
+     * - May create a Pull Request if `autoPr` is true (default).
+     *
+     * **Data Transformation:**
+     * - Resolves the `github` source identifier (e.g., `owner/repo`) to a full resource name.
+     * - Defaults `requirePlanApproval` to `false` for automated runs.
+     *
+     * @param config The configuration for the run.
+     * @returns A `AutomatedSession` object, which is an enhanced Promise that resolves to the final outcome.
+     * @throws {SourceNotFoundError} If the specified GitHub repository cannot be found or accessed.
+     * @throws {JulesApiError} If the session creation fails (e.g., 401 Unauthorized).
+     *
+     * @example
+     * const run = await jules.run({
+     *   prompt: "Fix the login bug",
+     *   source: { github: "my-org/repo", baseBranch: "main" }
+     * });
+     * const outcome = await run.result();
+     */
+    run(config: SessionConfig): Promise<AutomatedSession>;
+    /**
+     * Creates a new interactive session for workflows requiring human oversight.
+     *
+     * **Side Effects:**
+     * - Creates a new session on the Jules API (`POST /sessions`).
+     * - Initializes local storage for the session.
+     *
+     * **Data Transformation:**
+     * - Defaults `requirePlanApproval` to `true` for interactive sessions.
+     *
+     * @param config The configuration for the session.
+     * @returns A Promise resolving to the interactive `SessionClient`.
+     * @throws {SourceNotFoundError} If the source cannot be found.
+     *
+     * @example
+     * const session = await jules.session({
+     *   prompt: "Let's explore the codebase",
+     *   source: { github: "owner/repo", baseBranch: "main" }
+     * });
+     */
+    session(config: SessionConfig): Promise<SessionClient>;
+    /**
+     * Rehydrates an existing session from its ID, allowing you to resume interaction.
+     * This is useful for stateless environments (like serverless functions) where you need to
+     * reconnect to a long-running session.
+     *
+     * **Side Effects:**
+     * - Initializes local storage for the existing session ID.
+     * - Does NOT make a network request immediately (lazy initialization).
+     *
+     * @param sessionId The ID of the existing session.
+     * @returns The interactive `SessionClient`.
+     *
+     * @example
+     * const session = jules.session("12345");
+     * const info = await session.info(); // Now makes a request
+     */
+    session(sessionId: string): SessionClient;
+}

package/dist/core/src/errors.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Base class for all SDK-specific errors.
+ * This allows consumers to catch all Jules SDK errors with a single `catch` block.
+ */
+export declare class JulesError extends Error {
+    /** The original error that caused this error, if any. */
+    readonly cause?: Error;
+    constructor(message: string, options?: {
+        cause?: Error;
+    });
+}
+/**
+ * Thrown for fundamental network issues like fetch failures or timeouts.
+ */
+export declare class JulesNetworkError extends JulesError {
+    readonly url: string;
+    constructor(url: string, options?: {
+        cause?: Error;
+    });
+}
+/**
+ * A generic wrapper for non-2xx API responses that don't match other specific errors.
+ */
+export declare class JulesApiError extends JulesError {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    constructor(url: string, status: number, statusText: string, message?: string, // optional override
+    options?: {
+        cause?: Error;
+    });
+}
+/**
+ * Thrown for 401 Unauthorized or 403 Forbidden API responses.
+ */
+export declare class JulesAuthenticationError extends JulesApiError {
+    constructor(url: string, status: number, statusText: string);
+}
+/**
+ * Thrown for 429 Too Many Requests API responses.
+ */
+export declare class JulesRateLimitError extends JulesApiError {
+    constructor(url: string, status: number, statusText: string);
+}
+/**
+ * Thrown when an API key is required but not provided.
+ */
+export declare class MissingApiKeyError extends JulesError {
+    constructor();
+}
+/**
+ * Thrown when a requested source cannot be found.
+ */
+export declare class SourceNotFoundError extends JulesError {
+    constructor(sourceIdentifier: string);
+}
+/**
+ * Thrown when a jules.run() operation terminates in a FAILED state.
+ */
+export declare class AutomatedSessionFailedError extends JulesError {
+    constructor(reason?: string);
+}
+/**
+ * Thrown when an operation exceeds its specified timeout.
+ */
+export declare class TimeoutError extends JulesError {
+    constructor(message: string);
+}
+/**
+ * Thrown when attempting to start a sync while another sync is already in progress.
+ * This prevents data corruption and thundering herd issues.
+ */
+export declare class SyncInProgressError extends JulesError {
+    constructor();
+}
+/**
+ * Thrown when an operation is attempted on a session that is not in a
+ * valid state for that operation.
+ */
+export declare class InvalidStateError extends JulesError {
+    constructor(message: string);
+}

package/dist/core/src/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { JulesClient, JulesOptions } from './types.js';
+/**
+ * Connects to the Jules service using Node.js defaults (File System, Native Crypto).
+ * Acts as a factory method for creating a new client instance.
+ *
+ * @param options Configuration options for the client.
+ * @returns A new JulesClient instance.
+ */
+export declare function connect(options?: JulesOptions): JulesClient;
+/**
+ * The main entry point for the Jules SDK.
+ * This is a pre-initialized client that can be used immediately with default settings
+ * (e.g., reading API keys from environment variables).
+ *
+ * @example
+ * import { jules } from '@google/jules-sdk';
+ * const session = await jules.session({ ... });
+ */
+export declare const jules: JulesClient;
+export * from './errors.js';
+export type { Activity, ActivityAgentMessaged, ActivityPlanApproved, ActivityPlanGenerated, ActivityProgressUpdated, ActivitySummary, ActivitySessionCompleted, ActivitySessionFailed, ActivityUserMessaged, Artifact, AutomatedSession, ChangeSet, GitHubRepo, GitPatch, JulesClient, JulesOptions, LightweightActivity, LightweightArtifact, MediaArtifact, SessionOutcome as Outcome, ParsedChangeSet, ParsedFile, Plan, PlanStep, PullRequest, SessionClient, SessionConfig, SessionOutput, SessionResource, SessionState, Source, SourceContext, SourceInput, SourceManager, StrippedMediaArtifact, JulesQuery, JulesDomain, SyncDepth, SerializedSnapshot, SnapshotField, ToJSONOptions, } from './types.js';
+export { SESSION_SCHEMA, ACTIVITY_SCHEMA, FILTER_OP_SCHEMA, PROJECTION_SCHEMA, getSchema, getAllSchemas, generateTypeDefinition, generateMarkdownDocs, } from './query/schema.js';
+export type { FieldMeta, DomainSchema, QueryExample } from './query/schema.js';
+export { validateQuery, formatValidationResult } from './query/validate.js';
+export type { ValidationError, ValidationWarning, ValidationResult, ValidationErrorCode, } from './query/validate.js';
+export { SessionCursor } from './sessions.js';
+export type { ListSessionsOptions, ListSessionsResponse } from './sessions.js';
+export { toSummary } from './activities/summary.js';
+export { JulesClientImpl } from './client.js';
+export { MemoryStorage, MemorySessionStorage } from './storage/memory.js';
+export { NodePlatform } from './platform/node.js';
+export type { Platform } from './platform/types.js';
+export type { StorageFactory } from './types.js';
+export { ChangeSetArtifact, BashArtifact, parseUnidiff } from './artifacts.js';

package/dist/core/src/mappers.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Activity, Artifact, SessionOutcome, RestArtifact, SessionResource, RestSessionResource, RestSessionOutput, RestSource, SessionOutput, Source, SessionState } from './types.js';
+/**
+ * Maps a raw REST API Artifact resource to the SDK's `Artifact` type.
+ * This now instantiates rich classes for certain artifact types.
+ *
+ * @param restArtifact The raw artifact object from the REST API.
+ * @returns A structured `Artifact` object for the SDK.
+ * @internal
+ */
+export declare function mapRestArtifactToSdkArtifact(restArtifact: RestArtifact, platform: any, activityId?: string): Artifact;
+/**
+ * Maps a raw REST API Activity resource to the SDK's discriminated union `Activity` type.
+ *
+ * **Data Transformation:**
+ * - Flattens nested union fields (e.g., `agentMessaged`) into a top-level `type` property.
+ * - Extracts the short ID from the full resource `name`.
+ * - Recursively maps all artifacts within the activity.
+ *
+ * @param restActivity The raw activity object from the REST API.
+ * @param platform The platform adapter (needed for artifact mapping).
+ * @returns A structured `Activity` object for the SDK.
+ * @throws {Error} If the activity type is unknown.
+ * @internal
+ */
+export declare function mapRestActivityToSdkActivity(restActivity: any, platform: any): Activity;
+export declare function mapRestStateToSdkState(state: string): SessionState;
+export declare function mapRestSourceToSdkSource(rest: RestSource): Source;
+export declare function mapRestOutputToSdkOutput(rest: RestSessionOutput): SessionOutput;
+export declare function mapRestSessionToSdkSession(rest: RestSessionResource, platform?: any): SessionResource;
+/**
+ * Maps the final state of a SessionResource to a user-facing Outcome object.
+ * This includes extracting the primary pull request and handling the failed state.
+ *
+ * @param session The final SessionResource from the API.
+ * @returns The corresponding Outcome object.
+ * @throws {AutomatedSessionFailedError} If the session state is 'failed'.
+ */
+export declare function mapSessionResourceToOutcome(session: SessionResource): SessionOutcome;

package/dist/core/src/network/adapter.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ApiClient } from '../api.js';
+import { NetworkClient } from '../activities/client.js';
+import { Activity } from '../types.js';
+import { ListOptions } from '../activities/types.js';
+import { Platform } from '../platform/types.js';
+/**
+ * Concrete implementation of NetworkClient that communicates with the Jules API.
+ * Handles fetching activities and streaming them via polling.
+ */
+export declare class NetworkAdapter implements NetworkClient {
+    private apiClient;
+    private sessionId;
+    private pollingIntervalMs;
+    private platform;
+    constructor(apiClient: ApiClient, sessionId: string, pollingIntervalMs: number | undefined, platform: Platform);
+    /**
+     * Fetches a single activity from the API.
+     */
+    fetchActivity(activityId: string): Promise<Activity>;
+    /**
+     * Lists activities from the API with pagination.
+     */
+    listActivities(options?: ListOptions): Promise<{
+        activities: Activity[];
+        nextPageToken?: string;
+    }>;
+    /**
+     * Polls the API for new activities and yields them.
+     * This stream never ends unless the process is terminated.
+     */
+    rawStream(): AsyncIterable<Activity>;
+}

package/dist/core/src/platform/node.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Platform, PlatformResponse } from './types.js';
+/**
+ * Node.js implementation of the Platform interface.
+ */
+export declare class NodePlatform implements Platform {
+    /**
+     * Saves a file to the local filesystem using `node:fs/promises`.
+     *
+     * **Side Effects:**
+     * - Writes a file to disk.
+     * - Overwrites the file if it already exists.
+     */
+    saveFile(filepath: string, data: string, encoding: 'base64', activityId?: string): Promise<void>;
+    sleep(ms: number): Promise<void>;
+    createDataUrl(data: string, mimeType: string): string;
+    fetch(input: string, init?: any): Promise<PlatformResponse>;
+    crypto: {
+        randomUUID: () => `${string}-${string}-${string}-${string}-${string}`;
+        sign(text: string, secret: string): Promise<string>;
+        verify(text: string, signature: string, secret: string): Promise<boolean>;
+    };
+    encoding: {
+        base64Encode: (text: string) => string;
+        base64Decode: (text: string) => string;
+    };
+    getEnv(key: string): string | undefined;
+    readFile(path: string): Promise<string>;
+    writeFile(path: string, content: string): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+}

package/dist/core/src/platform/types.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * A unified response interface that works across Node, Browser, and GAS.
+ */
+export interface PlatformResponse {
+    ok: boolean;
+    status: number;
+    json<T = any>(): Promise<T>;
+    text(): Promise<string>;
+}
+/**
+ * Abstract interface for platform-specific functionality.
+ * Allows the SDK to run in both Node.js, browser, and Google Apps Script environments.
+ */
+export interface Platform {
+    /**
+     * Saves a file to the platform's filesystem.
+     */
+    saveFile(filepath: string, data: string, encoding: 'base64', activityId?: string): Promise<void>;
+    /**
+     * Pauses execution for the specified duration.
+     */
+    sleep(ms: number): Promise<void>;
+    /**
+     * Creates a data URL for the given data.
+     */
+    createDataUrl(data: string, mimeType: string): string;
+    /**
+     * Unified network fetch.
+     */
+    fetch(input: string, init?: any): Promise<PlatformResponse>;
+    /**
+     * Unified crypto operations.
+     */
+    crypto: {
+        /**
+         * Generates a standard UUID v4.
+         */
+        randomUUID(): string;
+        /**
+         * Signs a string using HMAC-SHA256 and returns a Base64Url encoded string.
+         * Used for minting Capability Tokens.
+         */
+        sign(text: string, secret: string): Promise<string>;
+        /**
+         * Verifies a signature.
+         */
+        verify(text: string, signature: string, secret: string): Promise<boolean>;
+    };
+    /**
+     * Unified encoding/decoding operations.
+     */
+    encoding: {
+        /**
+         * Encodes a string to Base64URL format.
+         * (URL-safe: '-' instead of '+', '_' instead of '/', no padding)
+         */
+        base64Encode(text: string): string;
+        /**
+         * Decodes a Base64URL encoded string.
+         */
+        base64Decode(text: string): string;
+    };
+    /**
+     * Retrieves an environment variable or configuration value.
+     *
+     * @param key The name of the environment variable (e.g., "JULES_API_KEY").
+     * @returns The value of the environment variable, or `undefined` if not set.
+     */
+    getEnv(key: string): string | undefined;
+    readFile?(path: string): Promise<string>;
+    writeFile?(path: string, content: string): Promise<void>;
+    deleteFile?(path: string): Promise<void>;
+}

package/dist/core/src/polling.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ApiClient } from './api.js';
+import { SessionResource } from './types.js';
+/**
+ * A generalized utility for polling the session resource until a specific
+ * condition is met.
+ *
+ * @param sessionId The ID of the session to poll.
+ * @param apiClient The API client for making requests.
+ * @param predicateFn A function that returns `true` if polling should stop.
+ * @param pollingInterval The interval in milliseconds between poll attempts.
+ * @param timeoutMs The maximum duration in milliseconds to poll before timing out.
+ * @returns The session resource that satisfied the predicate.
+ * @throws {TimeoutError} If the timeout is exceeded.
+ * @internal
+ */
+export declare function pollSession(sessionId: string, apiClient: ApiClient, predicateFn: (session: SessionResource) => boolean, pollingInterval: number, platform: any, timeoutMs?: number): Promise<SessionResource>;
+/**
+ * Polls the `GET /sessions/{id}` endpoint until the session reaches a terminal state.
+ *
+ * @param sessionId The ID of the session to poll.
+ * @param apiClient The API client for making requests.
+ * @param pollingInterval The interval in milliseconds between poll attempts.
+ * @param timeoutMs The maximum duration in milliseconds to poll before timing out.
+ * @returns The final SessionResource.
+ * @throws {TimeoutError} If the timeout is exceeded.
+ * @internal
+ */
+export declare function pollUntilCompletion(sessionId: string, apiClient: ApiClient, pollingInterval: number, platform: any, timeoutMs?: number): Promise<SessionResource>;