@boxrouter/sdk 0.0.1-alpha.0 → 0.12.190

package/dist/namespace-volumes.mjs

@@ -0,0 +1,269 @@
+import { HeyApiClient } from './namespace-base.mjs';
+export class Volumes extends HeyApiClient {
+    /**
+     * List volumes
+     *
+     * Lists volumes in the caller's workspace using cursor-based pagination. The response includes the current storage usage and live-volume policy only when those values are available.
+     */
+    list(options) {
+        return (options?.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes',
+            ...options
+        });
+    }
+    /**
+     * Create a volume
+     *
+     * The service selects its configured live backend when this workspace's live-volume policy allows creation. Backend identity is neither a request field nor a response label.
+     */
+    create(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Delete a volume and its checkpoints
+     *
+     * Deletes a volume and all checkpoint references and stored bytes for it. When the volume's writer is ending (its destroy was accepted), the call waits for the release, at most 120 seconds, before deleting. A running writer fails at once with volume_busy (409). Reuse a supplied Idempotency-Key with the identical request to reconcile an uncertain result; a conflicting active use can return 409.
+     */
+    delete(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}',
+            ...options
+        });
+    }
+    /**
+     * Get a volume
+     *
+     * Returns metadata for a BoxRouter-managed volume in the caller's workspace.
+     */
+    get(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}',
+            ...options
+        });
+    }
+    /**
+     * List volume checkpoints
+     *
+     * Lists committed checkpoints for this volume, newest first. A checkpoint created by an in-progress save is not listed until the save commits.
+     */
+    listCheckpoints(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/checkpoints',
+            ...options
+        });
+    }
+    /**
+     * Save a volume checkpoint
+     *
+     * Saves the current volume filesystem as an immutable checkpoint. The optional sandbox_id identifies the expected writer-lease holder; if omitted, the current holder is used. A mounted branch sandbox can be named to checkpoint its branch files without advancing the source volume's head. Read-only sandboxes cannot save. Reuse a supplied Idempotency-Key with the identical request to reconcile an uncertain response.
+     */
+    save(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/checkpoints',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Delete a checkpoint
+     *
+     * Removes the checkpoint reference. Backend data is reclaimed when the volume is erased.
+     */
+    deleteCheckpoint(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/checkpoints/{checkpoint}',
+            ...options
+        });
+    }
+    /**
+     * Get a volume checkpoint
+     *
+     * Returns an immutable committed checkpoint by its volume ID and checkpoint number.
+     */
+    getCheckpoint(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/checkpoints/{checkpoint}',
+            ...options
+        });
+    }
+    /**
+     * Release a volume's writer lease
+     *
+     * Releases the volume's writer lease and advances its epoch, invalidating the former writer's lease token. Reuse a supplied Idempotency-Key with the identical request to reconcile an uncertain result.
+     */
+    release(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/lease',
+            ...options
+        });
+    }
+    /**
+     * Create a volume file upload
+     *
+     * Creates a multipart upload for a file that will appear at
+     * `/workspace/<path>` in sandboxes. Upload every returned part URL with an
+     * HTTP PUT containing exactly that part's bytes; save the response `ETag`
+     * header for the completion request. Part URLs expire after six hours.
+     * An open upload blocks `write` sandboxes, and a live or pending `write`
+     * attachment blocks uploads (`volume_busy`). `read` and `shared` attachments
+     * may coexist, but their sandboxes may need to refresh their volume cache to
+     * see the new file.
+     *
+     */
+    createUpload(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/uploads',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Complete a volume file upload
+     *
+     * Supply each part number exactly once with the `ETag` header returned by its PUT response.
+     */
+    completeUpload(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/uploads/{upload_id}/complete',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Abort a volume file upload
+     *
+     * Aborts an open multipart upload for this volume. Repeating an abort is safe; the uploaded file is not made visible in the volume.
+     */
+    abortUpload(options) {
+        return (options.client ?? this.client).delete({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/uploads/{upload_id}',
+            ...options
+        });
+    }
+    /**
+     * Create a volume file download
+     *
+     * Creates a temporary download link that expires after one hour.
+     */
+    createDownload(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/downloads',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * List files in a volume
+     *
+     * Recursively lists files in path order without a directory delimiter. Read and shared sandboxes may need to refresh their volume cache to see new files.
+     */
+    listFiles(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/volumes/{volume_id}/files',
+            ...options
+        });
+    }
+}

package/dist/operations.d.ts

@@ -0,0 +1,14 @@
+import type { BoxRouterApi } from './sdk.gen';
+import type { Operation } from './types.gen';
+import type { RequestOptions } from './sandboxes';
+/** Read the recorded outcome of a mutation, or wait until it is no longer unknown. */
+export declare class OperationResources {
+    private readonly api;
+    constructor(api: BoxRouterApi);
+    /**
+     * Read an operation until its outcome is known, then return it. An `unknown` outcome stays unknown
+     * until BoxRouter reconciles it. Rejects with a TimeoutError when it is still unknown after the bound,
+     * and never repeats the mutation itself.
+     */
+    wait(id: string, options?: RequestOptions): Promise<Operation>;
+}

package/dist/operations.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationResources = void 0;
+const workflow_policy_gen_1 = require("./workflow-policy.gen");
+const waits_1 = require("./waits");
+/** Read the recorded outcome of a mutation, or wait until it is no longer unknown. */
+class OperationResources {
+    api;
+    constructor(api) {
+        this.api = api;
+    }
+    /**
+     * Read an operation until its outcome is known, then return it. An `unknown` outcome stays unknown
+     * until BoxRouter reconciles it. Rejects with a TimeoutError when it is still unknown after the bound,
+     * and never repeats the mutation itself.
+     */
+    async wait(id, options = {}) {
+        const read = () => this.api.operations.get({
+            path: { operation_id: id }, signal: options.signal
+        });
+        const first = await read();
+        return (0, waits_1.pollWhile)(first, {
+            pending: operation => workflow_policy_gen_1.OPERATION_WAIT_PENDING.includes(operation.outcome),
+            read,
+            timing: { intervalSeconds: workflow_policy_gen_1.OPERATION_WAIT_POLL_INTERVAL_SECONDS, boundSeconds: workflow_policy_gen_1.OPERATION_WAIT_BOUND_SECONDS },
+            timeout: () => new waits_1.WaitTimeoutError(id, `Operation ${id} is still ${first.outcome} after ${workflow_policy_gen_1.OPERATION_WAIT_BOUND_SECONDS} s; ` +
+                'inspect it before sending the request again'),
+        });
+    }
+}
+exports.OperationResources = OperationResources;

package/dist/retry.d.ts

@@ -0,0 +1,8 @@
+/** The client's `maxRetries`: an explicit count, or the shared default. */
+export declare function checkMaxRetries(value: number | undefined): number;
+/**
+ * Resend a call the server marked `retry: safe`, with the same idempotency key; every other failure
+ * goes to the caller. Only a call that can be sent twice is held for a resend: it has no body, or it
+ * carries an idempotency key.
+ */
+export declare function retryingFetch(fetch: () => typeof globalThis.fetch, maxRetries: number, sleep?: (seconds: number) => Promise<void>): typeof globalThis.fetch;

package/dist/retry.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMaxRetries = checkMaxRetries;
+exports.retryingFetch = retryingFetch;
+const workflow_policy_gen_1 = require("./workflow-policy.gen");
+/** Sent with a key made for this request; a resend must let Cloud check its record first. */
+const FIRST_SEND_HEADER = 'X-BoxRouter-First-Send';
+const wait = (seconds) => new Promise(resolve => setTimeout(resolve, seconds * 1000));
+/** The client's `maxRetries`: an explicit count, or the shared default. */
+function checkMaxRetries(value) {
+    if (value === undefined)
+        return workflow_policy_gen_1.DEFAULT_MAX_RETRIES;
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new TypeError('maxRetries must be a non-negative integer');
+    return value;
+}
+/** Seconds to wait before resending this response's request, or undefined to return it to the caller. */
+async function retryDelay(response, retriesMade, maxRetries) {
+    if (response.status < 400 || retriesMade >= maxRetries)
+        return undefined;
+    if (!(response.headers.get('content-type') ?? '').includes('json'))
+        return undefined;
+    let body;
+    try {
+        body = await response.clone().json();
+    }
+    catch {
+        return undefined;
+    }
+    const error = body !== null && typeof body === 'object' ? body.error : undefined;
+    if (error === null || typeof error !== 'object')
+        return undefined;
+    const { retry, retry_after_seconds: after } = error;
+    if (retry !== workflow_policy_gen_1.RETRY_WHEN)
+        return undefined;
+    const delay = typeof after === 'number' && Number.isFinite(after) && after >= 0
+        ? after : Math.min(workflow_policy_gen_1.RETRY_BASE_DELAY_SECONDS * 2 ** retriesMade, workflow_policy_gen_1.RETRY_MAX_DELAY_SECONDS);
+    return delay <= workflow_policy_gen_1.RETRY_MAX_DELAY_SECONDS ? delay : undefined;
+}
+/**
+ * Resend a call the server marked `retry: safe`, with the same idempotency key; every other failure
+ * goes to the caller. Only a call that can be sent twice is held for a resend: it has no body, or it
+ * carries an idempotency key.
+ */
+function retryingFetch(fetch, maxRetries, sleep = wait) {
+    return async (input, init) => {
+        let request = input instanceof Request && init === undefined ? input : new Request(input, init);
+        if (maxRetries === 0 || (request.body !== null && !request.headers.has('Idempotency-Key'))) {
+            return fetch()(request);
+        }
+        for (let retries = 0;; retries++) {
+            const replay = request.clone();
+            const response = await fetch()(request);
+            const delay = await retryDelay(response, retries, maxRetries);
+            if (delay === undefined)
+                return response;
+            await response.body?.cancel();
+            await sleep(delay);
+            replay.headers.delete(FIRST_SEND_HEADER);
+            request = replay;
+        }
+    };
+}

package/dist/routing-choices.gen.d.ts

@@ -0,0 +1,132 @@
+export declare const SORT_CHOICES: {
+    readonly price: {
+        readonly label: "Price";
+        readonly line: "Lowest hourly price first.";
+        readonly measure: "price";
+        readonly better: "lower";
+    };
+    readonly time: {
+        readonly label: "Time";
+        readonly line: "Shortest run time measured on reference workloads first.";
+        readonly measure: "time";
+        readonly better: "lower";
+    };
+};
+export declare const MODE_CHOICES: {
+    readonly automatic: {
+        readonly label: "Auto";
+        readonly line: "A random draw weighted toward lower hourly price.";
+    };
+    readonly cheapest: {
+        readonly label: "Cheapest";
+        readonly line: "Lowest hourly price first.";
+        readonly measure: "price";
+        readonly better: "lower";
+    };
+    readonly fastest: {
+        readonly label: "Fastest";
+        readonly line: "Shortest run time measured on reference workloads first.";
+        readonly measure: "time";
+        readonly better: "lower";
+    };
+    readonly custom: {
+        readonly label: "Custom";
+        readonly line: "Your exact provider order, top to bottom.";
+    };
+};
+export declare const OBJECTIVE_CHOICES: {
+    readonly default: {
+        readonly label: "Workspace setting";
+        readonly line: "Uses the workspace routing setting.";
+    };
+    readonly fastest: {
+        readonly label: "Fastest";
+        readonly line: "Shortest run time measured on reference workloads first.";
+        readonly measure: "time";
+        readonly better: "lower";
+    };
+    readonly cheapest: {
+        readonly label: "Cheapest";
+        readonly line: "Lowest hourly price first.";
+        readonly measure: "price";
+        readonly better: "lower";
+    };
+};
+export declare const RANKED_BY_CHOICES: {
+    readonly price: {
+        readonly label: "Price";
+        readonly line: "Lowest hourly price first.";
+        readonly measure: "price";
+        readonly better: "lower";
+    };
+    readonly time: {
+        readonly label: "Time";
+        readonly line: "Shortest run time measured on reference workloads first.";
+        readonly measure: "time";
+        readonly better: "lower";
+    };
+    readonly providers: {
+        readonly label: "Providers";
+        readonly line: "The hard list order.";
+    };
+    readonly order: {
+        readonly label: "Order";
+        readonly line: "A soft provider preference.";
+    };
+};
+export declare const RANKING_REASON_CHOICES: {
+    readonly lowest_price: {
+        readonly label: "Lowest price";
+        readonly line: "Lowest hourly price of the routes ranked together.";
+    };
+    readonly weighted_price: {
+        readonly label: "Weighted price";
+        readonly line: "Automatic mode leads with a draw weighted toward lower prices, so the leader can change between creates; the routes behind it follow by price.";
+    };
+    readonly lowest_time: {
+        readonly label: "Lowest time";
+        readonly line: "Shortest run time measured on reference workloads first.";
+    };
+    readonly predicted_completion: {
+        readonly label: "Predicted completion";
+        readonly line: "Soonest predicted completion among the routes ranked together.";
+    };
+    readonly predicted_ready_time: {
+        readonly label: "Predicted ready time";
+        readonly line: "Ordered by predicted time to ready from this workspace's history.";
+    };
+    readonly explicit_order: {
+        readonly label: "Explicit order";
+        readonly line: "Placed by the provider order you set in Routing or in the request.";
+    };
+    readonly after_named_providers: {
+        readonly label: "After named providers";
+        readonly line: "Behind the providers you named in your order; the others keep BoxRouter's ranking.";
+    };
+    readonly provider_key_order: {
+        readonly label: "Provider key order";
+        readonly line: "Another key of a provider already placed; one provider's keys are tried in the order you set in Routing.";
+    };
+    readonly only_eligible_route: {
+        readonly label: "Only eligible route";
+        readonly line: "Nothing else to rank it against in its group.";
+    };
+    readonly health_deprioritized: {
+        readonly label: "Health deprioritized";
+        readonly line: "Recent failures or degraded health put it behind healthier routes.";
+    };
+    readonly price_unknown: {
+        readonly label: "Price unknown";
+        readonly line: "No price quote at this size, so routes with a quote are tried first.";
+    };
+    readonly no_signals: {
+        readonly label: "No signals";
+        readonly line: "No price or time signals exist yet, so it keeps BoxRouter's default order.";
+    };
+};
+export declare const RUNNER_OBJECTIVE_CHOICES: {
+    readonly any: {
+        readonly label: "Any Fit";
+        readonly line: "on any available provider with this size.";
+    };
+};

package/dist/routing-choices.gen.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNNER_OBJECTIVE_CHOICES = exports.RANKING_REASON_CHOICES = exports.RANKED_BY_CHOICES = exports.OBJECTIVE_CHOICES = exports.MODE_CHOICES = exports.SORT_CHOICES = void 0;
+// Routing choice labels and meanings declared by OpenAPI (x-boxrouter-choices).
+exports.SORT_CHOICES = {
+    "price": {
+        "label": "Price",
+        "line": "Lowest hourly price first.",
+        "measure": "price",
+        "better": "lower"
+    },
+    "time": {
+        "label": "Time",
+        "line": "Shortest run time measured on reference workloads first.",
+        "measure": "time",
+        "better": "lower"
+    }
+};
+exports.MODE_CHOICES = {
+    "automatic": {
+        "label": "Auto",
+        "line": "A random draw weighted toward lower hourly price."
+    },
+    "cheapest": {
+        "label": "Cheapest",
+        "line": "Lowest hourly price first.",
+        "measure": "price",
+        "better": "lower"
+    },
+    "fastest": {
+        "label": "Fastest",
+        "line": "Shortest run time measured on reference workloads first.",
+        "measure": "time",
+        "better": "lower"
+    },
+    "custom": {
+        "label": "Custom",
+        "line": "Your exact provider order, top to bottom."
+    }
+};
+exports.OBJECTIVE_CHOICES = {
+    "default": {
+        "label": "Workspace setting",
+        "line": "Uses the workspace routing setting."
+    },
+    "fastest": {
+        "label": "Fastest",
+        "line": "Shortest run time measured on reference workloads first.",
+        "measure": "time",
+        "better": "lower"
+    },
+    "cheapest": {
+        "label": "Cheapest",
+        "line": "Lowest hourly price first.",
+        "measure": "price",
+        "better": "lower"
+    }
+};
+exports.RANKED_BY_CHOICES = {
+    "price": {
+        "label": "Price",
+        "line": "Lowest hourly price first.",
+        "measure": "price",
+        "better": "lower"
+    },
+    "time": {
+        "label": "Time",
+        "line": "Shortest run time measured on reference workloads first.",
+        "measure": "time",
+        "better": "lower"
+    },
+    "providers": {
+        "label": "Providers",
+        "line": "The hard list order."
+    },
+    "order": {
+        "label": "Order",
+        "line": "A soft provider preference."
+    }
+};
+exports.RANKING_REASON_CHOICES = {
+    "lowest_price": {
+        "label": "Lowest price",
+        "line": "Lowest hourly price of the routes ranked together."
+    },
+    "weighted_price": {
+        "label": "Weighted price",
+        "line": "Automatic mode leads with a draw weighted toward lower prices, so the leader can change between creates; the routes behind it follow by price."
+    },
+    "lowest_time": {
+        "label": "Lowest time",
+        "line": "Shortest run time measured on reference workloads first."
+    },
+    "predicted_completion": {
+        "label": "Predicted completion",
+        "line": "Soonest predicted completion among the routes ranked together."
+    },
+    "predicted_ready_time": {
+        "label": "Predicted ready time",
+        "line": "Ordered by predicted time to ready from this workspace's history."
+    },
+    "explicit_order": {
+        "label": "Explicit order",
+        "line": "Placed by the provider order you set in Routing or in the request."
+    },
+    "after_named_providers": {
+        "label": "After named providers",
+        "line": "Behind the providers you named in your order; the others keep BoxRouter's ranking."
+    },
+    "provider_key_order": {
+        "label": "Provider key order",
+        "line": "Another key of a provider already placed; one provider's keys are tried in the order you set in Routing."
+    },
+    "only_eligible_route": {
+        "label": "Only eligible route",
+        "line": "Nothing else to rank it against in its group."
+    },
+    "health_deprioritized": {
+        "label": "Health deprioritized",
+        "line": "Recent failures or degraded health put it behind healthier routes."
+    },
+    "price_unknown": {
+        "label": "Price unknown",
+        "line": "No price quote at this size, so routes with a quote are tried first."
+    },
+    "no_signals": {
+        "label": "No signals",
+        "line": "No price or time signals exist yet, so it keeps BoxRouter's default order."
+    }
+};
+exports.RUNNER_OBJECTIVE_CHOICES = {
+    "any": {
+        "label": "Any Fit",
+        "line": "on any available provider with this size."
+    }
+};

package/dist/routing.d.ts

@@ -0,0 +1,23 @@
+import type { BoxRouterApi } from './sdk.gen';
+import type { ProviderFundingUpdate, ProviderSlug, RoutingFieldsUpdate } from './types.gen';
+import type { RequestOptions } from './sandboxes';
+type RoutingApi = BoxRouterApi['routing'];
+type Settings = Awaited<ReturnType<RoutingApi['settings']>>;
+type Preview = Awaited<ReturnType<RoutingApi['preview']>>;
+/** Guard a routing write with the section token read from `settings().section_etags`. */
+export interface RoutingWriteOptions extends RequestOptions {
+    ifMatch?: string;
+}
+/** Workspace Routing settings and read-only availability preview. */
+export declare class RoutingResources {
+    private readonly api;
+    constructor(api: BoxRouterApi);
+    settings(options?: RequestOptions): Promise<Settings>;
+    /** Change only the routing fields you give; omitted fields keep their stored values. */
+    update(fields: RoutingFieldsUpdate, options?: RoutingWriteOptions): Promise<Settings>;
+    /** Change only the funding fields you give for one provider. */
+    updateFunding(provider: ProviderSlug, funding: ProviderFundingUpdate, options?: RoutingWriteOptions): Promise<Settings>;
+    /** Read current routing availability; this is not a route prediction. */
+    preview(options?: RequestOptions): Promise<Preview>;
+}
+export {};