@barndoor-ai/sdk 1.2.0 → 2.0.0-dev.g37b8897

package/dist/lib/http.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * The fetch the generated client runs every request through.
+ *
+ * `Configuration.fetchApi` is the single choke point — runtime.ts calls
+ * `(this.configuration.fetchApi || fetch)(...)` once, beneath the middleware
+ * chain, so retries belong here rather than in a `Middleware`: a `post` hook
+ * would see each attempt, and an `onError` hook cannot retry a response that
+ * arrived successfully with a 503.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFetch = createFetch;
+/**
+ * Statuses worth another attempt.
+ *
+ * 5xx generally, plus 429. 501 and 505 are excluded: the server understood the
+ * request and will refuse it identically next time.
+ */
+function isRetryableStatus(status) {
+    if (status === 429)
+        return true;
+    return status >= 500 && status !== 501 && status !== 505;
+}
+/**
+ * Only idempotent methods are retried.
+ *
+ * A 502 or 504 does not say whether the request reached the application — a
+ * gateway can time out waiting for a response to work it already committed. So
+ * retrying a POST risks a duplicate write, and silently doing that is worse
+ * than surfacing the error. The hand-written SDK retried every method, which
+ * was a latent double-write on any 5xx during a create.
+ */
+const IDEMPOTENT = new Set(['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE']);
+/** `Retry-After` is either seconds or an HTTP date; both are legal. */
+function retryAfterMs(response) {
+    const header = response.headers.get('retry-after');
+    if (!header)
+        return null;
+    const seconds = Number(header);
+    if (Number.isFinite(seconds))
+        return Math.max(0, seconds * 1000);
+    const date = Date.parse(header);
+    return Number.isNaN(date) ? null : Math.max(0, date - Date.now());
+}
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+function createFetch(options = {}) {
+    const { retries = 3, timeoutMs = 30_000, backoffMs = 250 } = options;
+    const underlying = options.fetch ?? ((url, init) => globalThis.fetch(url, init));
+    return async function fetchWithRetry(url, init = {}) {
+        let lastError;
+        for (let attempt = 0;; attempt++) {
+            // A fresh timeout per attempt, combined with whatever the caller passed so
+            // their cancellation still wins and is never retried past.
+            const timeout = AbortSignal.timeout(timeoutMs);
+            const signal = init.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
+            let response;
+            try {
+                response = await underlying(url, { ...init, signal });
+            }
+            catch (error) {
+                lastError = error;
+                // The caller aborted, or the request is not safe to repeat.
+                if (init.signal?.aborted)
+                    throw error;
+                if (!IDEMPOTENT.has((init.method ?? 'GET').toUpperCase()))
+                    throw error;
+                if (attempt >= retries)
+                    throw error;
+                await sleep(backoffMs * 2 ** attempt);
+                continue;
+            }
+            if (attempt >= retries ||
+                !isRetryableStatus(response.status) ||
+                !IDEMPOTENT.has((init.method ?? 'GET').toUpperCase())) {
+                return response;
+            }
+            // The body is never read on a retried response, so release it rather than
+            // leaking the connection.
+            await response.body?.cancel().catch(() => undefined);
+            await sleep(retryAfterMs(response) ?? backoffMs * 2 ** attempt);
+        }
+    };
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The hand-written half of the SDK.
+ *
+ * Everything else under `src/` is generated from `docs/api/public-openapi.yaml`
+ * and is not committed — `make gen-sdk-typescript` recreates it. This directory
+ * holds only what an OpenAPI document cannot describe: obtaining a token,
+ * transport resilience, non-production hosts, and the MCP client.
+ *
+ * Re-exported from the package root by `templates/index.mustache`.
+ */
+export { createClient, type BarndoorClient, type ClientOptions } from './client.js';
+export { clientCredentials, completeAuthorizationCode, refreshToken, startAuthorizationCode, staticToken, type AuthorizationCodeOptions, type AuthorizationCodeRequest, type ClientCredentialsOptions, type TokenProvider, } from './auth.js';
+export { DEV, LOCAL, environmentFromEnv, type Environment } from './config.js';
+export { createFetch, type RetryOptions } from './http.js';
+export { createMcpClient, mcpConnectionParams, type McpOptions } from './mcp.js';

package/dist/lib/index.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * The hand-written half of the SDK.
+ *
+ * Everything else under `src/` is generated from `docs/api/public-openapi.yaml`
+ * and is not committed — `make gen-sdk-typescript` recreates it. This directory
+ * holds only what an OpenAPI document cannot describe: obtaining a token,
+ * transport resilience, non-production hosts, and the MCP client.
+ *
+ * Re-exported from the package root by `templates/index.mustache`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpConnectionParams = exports.createMcpClient = exports.createFetch = exports.environmentFromEnv = exports.LOCAL = exports.DEV = exports.staticToken = exports.startAuthorizationCode = exports.refreshToken = exports.completeAuthorizationCode = exports.clientCredentials = exports.createClient = void 0;
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return client_js_1.createClient; } });
+var auth_js_1 = require("./auth.js");
+Object.defineProperty(exports, "clientCredentials", { enumerable: true, get: function () { return auth_js_1.clientCredentials; } });
+Object.defineProperty(exports, "completeAuthorizationCode", { enumerable: true, get: function () { return auth_js_1.completeAuthorizationCode; } });
+Object.defineProperty(exports, "refreshToken", { enumerable: true, get: function () { return auth_js_1.refreshToken; } });
+Object.defineProperty(exports, "startAuthorizationCode", { enumerable: true, get: function () { return auth_js_1.startAuthorizationCode; } });
+Object.defineProperty(exports, "staticToken", { enumerable: true, get: function () { return auth_js_1.staticToken; } });
+var config_js_1 = require("./config.js");
+Object.defineProperty(exports, "DEV", { enumerable: true, get: function () { return config_js_1.DEV; } });
+Object.defineProperty(exports, "LOCAL", { enumerable: true, get: function () { return config_js_1.LOCAL; } });
+Object.defineProperty(exports, "environmentFromEnv", { enumerable: true, get: function () { return config_js_1.environmentFromEnv; } });
+var http_js_1 = require("./http.js");
+Object.defineProperty(exports, "createFetch", { enumerable: true, get: function () { return http_js_1.createFetch; } });
+var mcp_js_1 = require("./mcp.js");
+Object.defineProperty(exports, "createMcpClient", { enumerable: true, get: function () { return mcp_js_1.createMcpClient; } });
+Object.defineProperty(exports, "mcpConnectionParams", { enumerable: true, get: function () { return mcp_js_1.mcpConnectionParams; } });

package/dist/lib/mcp.d.ts

@@ -0,0 +1,41 @@
+import { Client as McpClient } from '@modelcontextprotocol/sdk/client/index.js';
+import { type BarndoorClient } from './client.js';
+/**
+ * Connecting to an MCP server through Barndoor.
+ *
+ * This is the one capability the spec cannot describe: MCP is a different
+ * protocol over its own transport, and nothing in an OpenAPI document says a
+ * server is reachable at /mcp or what headers that needs. The REST half is used
+ * only to exchange a server id for a slug.
+ */
+export interface McpOptions {
+    /**
+     * The host serving MCP, WITHOUT the organization subdomain. Defaults to the
+     * client's API base URL, since one vhost serves both `/api` and `/mcp`.
+     */
+    baseUrl?: string;
+    /** Correlates every call in one session in Barndoor's audit trail. */
+    sessionId?: string;
+    /** Reported to the MCP server during initialisation. */
+    clientInfo?: {
+        name: string;
+        version: string;
+    };
+}
+/** The URL and headers an MCP transport needs, for callers wiring their own. */
+export declare function mcpConnectionParams(client: BarndoorClient, orgSlug: string, serverIdOrSlug?: string, options?: McpOptions): Promise<{
+    url: string;
+    headers: Record<string, string>;
+}>;
+/**
+ * Open a connected MCP session.
+ *
+ * Omit `serverIdOrSlug` for the universal endpoint (`/mcp`), which exposes
+ * every server the caller can reach; pass one to connect directly to a single
+ * server (`/mcp/<slug>`). A server id is accepted and exchanged for its slug.
+ *
+ * Returns the official `@modelcontextprotocol/sdk` client, already through
+ * `initialize`, so callers use the MCP API directly rather than anything
+ * Barndoor-shaped. Close it with `client.close()`.
+ */
+export declare function createMcpClient(client: BarndoorClient, orgSlug: string, serverIdOrSlug?: string, options?: McpOptions): Promise<McpClient>;

package/dist/lib/mcp.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpConnectionParams = mcpConnectionParams;
+exports.createMcpClient = createMcpClient;
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const runtime_js_1 = require("../runtime.js");
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * `crypto.randomUUID` is undefined outside a secure context, so a browser
+ * served over plain HTTP would throw rather than produce a session id.
+ */
+function newSessionId() {
+    if (typeof globalThis.crypto?.randomUUID === 'function')
+        return globalThis.crypto.randomUUID();
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+/** Put the tenant in front of the host: platform.example.com -> acme.platform.example.com */
+function withOrganization(baseUrl, orgSlug) {
+    const url = new URL(baseUrl);
+    url.hostname = `${orgSlug}.${url.hostname}`;
+    return url;
+}
+/**
+ * A server id is exchanged for its slug; a slug is used as given.
+ *
+ * The MCP endpoint addresses servers by slug only, and the two are told apart
+ * by shape — which is what the REST API does with its `{server_id}` and
+ * `by-slug/{slug}` routes.
+ */
+async function resolveSlug(client, serverIdOrSlug) {
+    if (!UUID.test(serverIdOrSlug))
+        return serverIdOrSlug;
+    const server = await client.registry.getMcpServer({ serverId: serverIdOrSlug });
+    if (!server.slug) {
+        throw new Error(`Server ${serverIdOrSlug} has no slug, so it cannot be reached over MCP`);
+    }
+    return server.slug;
+}
+/** The URL and headers an MCP transport needs, for callers wiring their own. */
+async function mcpConnectionParams(client, orgSlug, serverIdOrSlug, options = {}) {
+    if (!orgSlug) {
+        throw new Error('An organization slug is required: it selects the tenant serving MCP');
+    }
+    const url = withOrganization(options.baseUrl ?? client.configuration.basePath ?? runtime_js_1.BASE_PATH, orgSlug);
+    // Omitting the server connects to the universal endpoint, which exposes every
+    // server the caller can reach as one surface. Naming one connects directly to
+    // just that server.
+    url.pathname = serverIdOrSlug ? `/mcp/${await resolveSlug(client, serverIdOrSlug)}` : '/mcp';
+    // The same provider the generated operations authenticate with, so an MCP
+    // session cannot end up on a different or stale credential.
+    const accessToken = client.configuration.accessToken;
+    if (!accessToken) {
+        throw new Error('This client has no credential, so it cannot open an MCP session');
+    }
+    return {
+        url: url.href,
+        headers: {
+            Accept: 'application/json, text/event-stream',
+            Authorization: `Bearer ${await accessToken('OAuth2', [])}`,
+            'x-barndoor-session-id': options.sessionId ?? newSessionId(),
+        },
+    };
+}
+/**
+ * Open a connected MCP session.
+ *
+ * Omit `serverIdOrSlug` for the universal endpoint (`/mcp`), which exposes
+ * every server the caller can reach; pass one to connect directly to a single
+ * server (`/mcp/<slug>`). A server id is accepted and exchanged for its slug.
+ *
+ * Returns the official `@modelcontextprotocol/sdk` client, already through
+ * `initialize`, so callers use the MCP API directly rather than anything
+ * Barndoor-shaped. Close it with `client.close()`.
+ */
+async function createMcpClient(client, orgSlug, serverIdOrSlug, options = {}) {
+    const { url, headers } = await mcpConnectionParams(client, orgSlug, serverIdOrSlug, options);
+    const mcp = new index_js_1.Client(options.clientInfo ?? { name: 'barndoor-sdk', version: '0.1.0' });
+    const transport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(url), { requestInit: { headers } });
+    await mcp.connect(transport);
+    return mcp;
+}

package/dist/models/AWSTrustInfoResponse.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Barndoor.ai Public API
+ * Unified public API specification for Barndoor.ai platform
+ *
+ * The version of the OpenAPI document: 2.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface AWSTrustInfoResponse
+ */
+export interface AWSTrustInfoResponse {
+    /**
+     *
+     */
+    externalId: string;
+    /**
+     *
+     */
+    principalArn: string;
+}
+/**
+ * Check if a given object implements the AWSTrustInfoResponse interface.
+ */
+export declare function instanceOfAWSTrustInfoResponse(value: object): value is AWSTrustInfoResponse;
+export declare function AWSTrustInfoResponseFromJSON(json: any): AWSTrustInfoResponse;
+export declare function AWSTrustInfoResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): AWSTrustInfoResponse;
+export declare function AWSTrustInfoResponseToJSON(json: any): AWSTrustInfoResponse;
+export declare function AWSTrustInfoResponseToJSONTyped(value?: AWSTrustInfoResponse | null, ignoreDiscriminator?: boolean): any;

package/dist/models/AWSTrustInfoResponse.js

@@ -0,0 +1,54 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Barndoor.ai Public API
+ * Unified public API specification for Barndoor.ai platform
+ *
+ * The version of the OpenAPI document: 2.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfAWSTrustInfoResponse = instanceOfAWSTrustInfoResponse;
+exports.AWSTrustInfoResponseFromJSON = AWSTrustInfoResponseFromJSON;
+exports.AWSTrustInfoResponseFromJSONTyped = AWSTrustInfoResponseFromJSONTyped;
+exports.AWSTrustInfoResponseToJSON = AWSTrustInfoResponseToJSON;
+exports.AWSTrustInfoResponseToJSONTyped = AWSTrustInfoResponseToJSONTyped;
+/**
+ * Check if a given object implements the AWSTrustInfoResponse interface.
+ */
+function instanceOfAWSTrustInfoResponse(value) {
+    if ((!('externalId' in value) && !('external_id' in value)) || (value['externalId'] === undefined && value['external_id'] === undefined))
+        return false;
+    if ((!('principalArn' in value) && !('principal_arn' in value)) || (value['principalArn'] === undefined && value['principal_arn'] === undefined))
+        return false;
+    return true;
+}
+function AWSTrustInfoResponseFromJSON(json) {
+    return AWSTrustInfoResponseFromJSONTyped(json, false);
+}
+function AWSTrustInfoResponseFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'externalId': json['external_id'],
+        'principalArn': json['principal_arn'],
+    };
+}
+function AWSTrustInfoResponseToJSON(json) {
+    return AWSTrustInfoResponseToJSONTyped(json, false);
+}
+function AWSTrustInfoResponseToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'external_id': value['externalId'],
+        'principal_arn': value['principalArn'],
+    };
+}

package/dist/models/AddRouteGroupMembersRequest.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Barndoor.ai Public API
+ * Unified public API specification for Barndoor.ai platform
+ *
+ * The version of the OpenAPI document: 2.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface AddRouteGroupMembersRequest
+ */
+export interface AddRouteGroupMembersRequest {
+    /**
+     * Optional free-text note explaining why these routes were added
+     * (BCP-3998). Recorded on the group, which is where membership
+     * attribution lives — see the `ModelRouteGroup::attribution` docs.
+     */
+    changeNote?: string | null;
+    /**
+     *
+     */
+    modelAliases: Array<string>;
+}
+/**
+ * Check if a given object implements the AddRouteGroupMembersRequest interface.
+ */
+export declare function instanceOfAddRouteGroupMembersRequest(value: object): value is AddRouteGroupMembersRequest;
+export declare function AddRouteGroupMembersRequestFromJSON(json: any): AddRouteGroupMembersRequest;
+export declare function AddRouteGroupMembersRequestFromJSONTyped(json: any, ignoreDiscriminator: boolean): AddRouteGroupMembersRequest;
+export declare function AddRouteGroupMembersRequestToJSON(json: any): AddRouteGroupMembersRequest;
+export declare function AddRouteGroupMembersRequestToJSONTyped(value?: AddRouteGroupMembersRequest | null, ignoreDiscriminator?: boolean): any;

package/dist/models/AddRouteGroupMembersRequest.js

@@ -0,0 +1,52 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Barndoor.ai Public API
+ * Unified public API specification for Barndoor.ai platform
+ *
+ * The version of the OpenAPI document: 2.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfAddRouteGroupMembersRequest = instanceOfAddRouteGroupMembersRequest;
+exports.AddRouteGroupMembersRequestFromJSON = AddRouteGroupMembersRequestFromJSON;
+exports.AddRouteGroupMembersRequestFromJSONTyped = AddRouteGroupMembersRequestFromJSONTyped;
+exports.AddRouteGroupMembersRequestToJSON = AddRouteGroupMembersRequestToJSON;
+exports.AddRouteGroupMembersRequestToJSONTyped = AddRouteGroupMembersRequestToJSONTyped;
+/**
+ * Check if a given object implements the AddRouteGroupMembersRequest interface.
+ */
+function instanceOfAddRouteGroupMembersRequest(value) {
+    if ((!('modelAliases' in value) && !('model_aliases' in value)) || (value['modelAliases'] === undefined && value['model_aliases'] === undefined))
+        return false;
+    return true;
+}
+function AddRouteGroupMembersRequestFromJSON(json) {
+    return AddRouteGroupMembersRequestFromJSONTyped(json, false);
+}
+function AddRouteGroupMembersRequestFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'changeNote': json['change_note'] === undefined ? undefined : json['change_note'] === null ? null : json['change_note'],
+        'modelAliases': json['model_aliases'],
+    };
+}
+function AddRouteGroupMembersRequestToJSON(json) {
+    return AddRouteGroupMembersRequestToJSONTyped(json, false);
+}
+function AddRouteGroupMembersRequestToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'change_note': value['changeNote'],
+        'model_aliases': value['modelAliases'],
+    };
+}

package/dist/models/AdminModelPricing.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Barndoor.ai Public API
+ * Unified public API specification for Barndoor.ai platform
+ *
+ * The version of the OpenAPI document: 2.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { PricingChangeSource } from './PricingChangeSource.js';
+import type { LongContextTier } from './LongContextTier.js';
+import type { PricingSyncMode } from './PricingSyncMode.js';
+/**
+ * Admin-API response shape for a single pricing row. Wraps the
+ * `ai_governance::ModelPricing` used by the cost calculator so that the hot
+ * path stays sync-mode-agnostic, while the admin surface still gets the
+ * metadata it needs to render badges, the Review-updates dialog, and (as
+ * of BCP-2830 v2 / V34) the per-row history timeline.
+ * @export
+ * @interface AdminModelPricing
+ */
+export interface AdminModelPricing {
+    /**
+     * Per-million-token cost for input tokens served from the prompt
+     * cache. `None` ⇒ the calculator bills cached input at
+     * `input_cost_per_million_tokens`.
+     */
+    cacheReadCostPerMillionTokens?: number;
+    /**
+     * Per-million-token cost for input tokens added to the prompt cache.
+     * `None` ⇒ same fallback as `cache_read_cost_per_million_tokens`.
+     */
+    cacheWriteCostPerMillionTokens?: number;
+    /**
+     * Catalog slug for provider-level pricing (e.g. "openai", "aws_bedrock").
+     */
+    catalogSlug?: string;
+    /**
+     *
+     */
+    effectiveFrom: Date;
+    /**
+     *
+     */
+    id: string;
+    /**
+     *
+     */
+    inputCostPerMillionTokens: number;
+    /**
+     * Optional context-tiered surcharge (BCP-3904). `None` ⇒ one rate set
+     * at every prompt size, i.e. exactly the pre-BCP-3904 behaviour.
+     *
+     * Serialized as `long_context`, not as the Rust field name. This struct
+     * reaches the admin API through `AdminModelPricing`'s
+     * `#[serde(flatten)]`, so the field name here *is* the wire key — and
+     * every sibling surface (`DefaultPricingEntry`, `EffectivePricing`, the
+     * create/update request bodies) already spells it `long_context`. Left
+     * unrenamed, the pricing tab would write a tier successfully and then
+     * read back nothing, which is precisely how it behaved before this
+     * attribute existed: the surcharge saved, the dialog reopened unchecked,
+     * and the edit looked silently discarded. Pinned by
+     * `admin_model_pricing_serializes_the_tier_as_long_context`.
+     */
+    longContext?: LongContextTier;
+    /**
+     *
+     */
+    modelPattern: string;
+    /**
+     *
+     */
+    modelProvider?: string;
+    /**
+     *
+     */
+    orgId: string;
+    /**
+     *
+     */
+    outputCostPerMillionTokens: number;
+    /**
+     * Optional reference to a specific LLM Gateway provider instance.
+     */
+    providerId?: string;
+    /**
+     *
+     */
+    providerName?: string;
+    /**
+     *
+     */
+    changeReason?: string | null;
+    /**
+     *
+     */
+    changeSource: PricingChangeSource;
+    /**
+     *
+     */
+    createdByEmail?: string | null;
+    /**
+     *
+     */
+    createdByName?: string | null;
+    /**
+     *
+     */
+    createdByUserId?: string | null;
+    /**
+     * True for tombstone rows produced by `archive_rule` (V35). When
+     * the latest effective version of a group has `is_archived = true`,
+     * the rule is considered archived: the cost calculator skips it
+     * and the admin summary list hides it by default. Past non-archived
+     * versions remain in the timeline so the History dialog can show
+     * the rule's full life including the archive event.
+     */
+    isArchived: boolean;
+    /**
+     *
+     */
+    syncMode: PricingSyncMode;
+}
+/**
+ * Check if a given object implements the AdminModelPricing interface.
+ */
+export declare function instanceOfAdminModelPricing(value: object): value is AdminModelPricing;
+export declare function AdminModelPricingFromJSON(json: any): AdminModelPricing;
+export declare function AdminModelPricingFromJSONTyped(json: any, ignoreDiscriminator: boolean): AdminModelPricing;
+export declare function AdminModelPricingToJSON(json: any): AdminModelPricing;
+export declare function AdminModelPricingToJSONTyped(value?: AdminModelPricing | null, ignoreDiscriminator?: boolean): any;