@beeuni/sdk 0.1.0

package/dist/core/rest/projects-client/secrets.d.ts

@@ -0,0 +1,187 @@
+import type { ConnectionShare } from './connectors.js';
+import { type ConnectorSharing, type ProjectGitConnection } from './shared.js';
+export type SecretDeliveryStrategy = 'runtime' | 'egress' | 'broker' | 'denied';
+export type SecretConsumer = 'sandbox' | 'llm_gateway' | 'connector' | 'git_proxy' | 'http_broker' | 'network';
+export type SecretDeliveryStatus = 'available' | 'unavailable' | 'disabled';
+export type SecretDeliveryBlockedReason = 'no_agent_grant';
+export type SecretInjectionSlot = {
+    kind: 'header';
+    name: string;
+    template?: string;
+} | {
+    kind: 'query';
+    name: string;
+} | {
+    kind: 'json_body_field';
+    path: string;
+};
+export interface SecretEgressRule {
+    host: string;
+    methods?: string[];
+    path?: string;
+    inject?: SecretInjectionSlot;
+}
+export interface SecretEgressPolicy {
+    backend?: 'llm_gateway' | 'connector' | 'git_proxy' | 'beeuni_fetch';
+    base_url_env?: string;
+    rules: SecretEgressRule[];
+    inject?: SecretInjectionSlot;
+    on_no_match?: 'deny' | 'observe';
+    tls?: 'terminate' | 'tunnel';
+}
+export interface UpdateSecretStrategyOptions {
+    consumer?: SecretConsumer | null;
+    egress_policy?: SecretEgressPolicy;
+    handle_prefix?: string;
+}
+export interface SecretBrokerRequest {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+    headers?: Record<string, string>;
+    body_base64?: string;
+}
+export interface SecretBrokerResponse {
+    status: number;
+    headers: Record<string, string>;
+    body_base64: string;
+}
+export interface ProjectSecret {
+    identifier: string;
+    name: string;
+    project_id: string;
+    secret_id: string | null;
+    created_by: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+    system?: boolean;
+    readonly?: boolean;
+    purpose?: string | null;
+    can_rotate?: boolean;
+    managed_by?: string | null;
+    configured: boolean;
+    mine: {
+        active: boolean;
+        updated_at: string;
+    } | null;
+    effective_source: 'mine' | 'shared' | 'none';
+    can_manage_shared: boolean;
+    strategy?: SecretDeliveryStrategy;
+    consumer?: SecretConsumer | null;
+    delivery_status?: SecretDeliveryStatus;
+    delivery_blocked_reason?: SecretDeliveryBlockedReason | null;
+    network_boundary_available?: boolean;
+    egress_policy?: SecretEgressPolicy | null;
+    strategy_locked?: boolean;
+    last_rotated_at?: string | null;
+    requires_rotation?: boolean;
+    shared_with?: ConnectionShare[];
+    usable?: boolean;
+}
+export interface SecretSharePrincipal {
+    principal_type: 'user' | 'group' | 'agent';
+    principal_id: string;
+}
+export interface ProjectSecretsResponse {
+    items: ProjectSecret[];
+    can_manage?: boolean;
+    required: string[];
+    optional: string[];
+    manifest_status?: 'loaded' | 'missing' | 'error';
+    manifest_path?: string;
+    manifest_error?: string;
+    agent_scope?: ProjectSecretsAgentScope | null;
+}
+export interface ProjectSecretsAgentScope {
+    agent: string;
+    secrets: 'all' | string[];
+}
+export declare function listProjectSecrets(projectId: string): Promise<ProjectSecretsResponse>;
+export declare function upsertProjectSecret(projectId: string, input: {
+    name: string;
+    identifier?: string;
+    consumer?: SecretConsumer | null;
+    strategy?: SecretDeliveryStrategy;
+    egress_policy?: SecretEgressPolicy;
+    handle_prefix?: string;
+    value?: string;
+    shared_with?: SecretSharePrincipal[];
+}): Promise<ProjectSecret>;
+export declare function setProjectSecretStrategy(projectId: string, identifier: string, strategy: SecretDeliveryStrategy, options?: UpdateSecretStrategyOptions): Promise<ProjectSecret>;
+export declare function brokerProjectSecretRequest(projectId: string, identifier: string, input: SecretBrokerRequest): Promise<SecretBrokerResponse>;
+export interface ProviderOAuthStart {
+    flow_id: string;
+    verification_url: string;
+    user_code: string | null;
+    expires_at: number;
+    interval_ms: number;
+}
+export interface ProviderOAuthCredential {
+    provider_id: string;
+    secret_id?: string;
+    label?: string;
+    expires_in_ms: number | null;
+    updated_at: string;
+}
+export type ProviderOAuthPoll = {
+    status: 'pending';
+    next_poll_ms?: number;
+} | {
+    status: 'success';
+    credential: ProviderOAuthCredential;
+} | {
+    status: 'expired';
+} | {
+    status: 'failed';
+    error: string;
+};
+export declare function listProjectProviderOAuth(projectId: string): Promise<ProviderOAuthCredential[]>;
+export declare function startProjectProviderOAuth(projectId: string, provider: string, input?: {
+    sharing?: ConnectorSharing;
+    resourceLabel?: string;
+    resourceId?: string;
+}): Promise<ProviderOAuthStart>;
+export declare function pollProjectProviderOAuth(projectId: string, provider: string, flowId: string): Promise<ProviderOAuthPoll>;
+export declare function deleteProjectProviderOAuth(projectId: string, provider: string): Promise<{
+    ok: boolean;
+}>;
+export interface ProjectProviderOAuthFlowOptions {
+    projectId: string;
+    provider: string;
+    input?: Parameters<typeof startProjectProviderOAuth>[2];
+    onChallenge?: (challenge: {
+        verification_url: string;
+        user_code: string | null;
+    }) => void;
+    isCancelled?: () => boolean;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+}
+export type ProjectProviderOAuthFlowResult = {
+    status: 'success';
+    credential: ProviderOAuthCredential;
+} | {
+    status: 'failed';
+    error: string;
+} | {
+    status: 'expired';
+} | {
+    status: 'cancelled';
+};
+export declare function runProjectProviderOAuthFlow(options: ProjectProviderOAuthFlowOptions): Promise<ProjectProviderOAuthFlowResult>;
+export declare function upsertProjectGitCredential(projectId: string, input: {
+    token: string;
+}): Promise<{
+    configured: boolean;
+    provider: string;
+    git_connection: ProjectGitConnection;
+}>;
+export declare function deleteProjectSecret(projectId: string, identifier: string): Promise<{
+    ok: boolean;
+}>;
+export declare function setPersonalProjectSecret(projectId: string, name: string, input: {
+    value?: string;
+    active?: boolean;
+}): Promise<ProjectSecret>;
+export declare function deletePersonalProjectSecret(projectId: string, name: string): Promise<{
+    ok: boolean;
+}>;

package/dist/core/rest/projects-client/secrets.js

@@ -0,0 +1,79 @@
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+export async function listProjectSecrets(projectId) {
+    return unwrap(await backendApi.get(`/projects/${projectId}/secrets`, { showErrors: false }));
+}
+export async function upsertProjectSecret(projectId, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/secrets`, input));
+}
+export async function setProjectSecretStrategy(projectId, identifier, strategy, options = {}) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/secrets/${encodeURIComponent(identifier)}/strategy`, { strategy, ...options }));
+}
+export async function brokerProjectSecretRequest(projectId, identifier, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/secrets/${encodeURIComponent(identifier)}/broker`, input));
+}
+export async function listProjectProviderOAuth(projectId) {
+    const result = unwrap(await backendApi.get(`/projects/${projectId}/oauth`));
+    return result.items ?? [];
+}
+export async function startProjectProviderOAuth(projectId, provider, input) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/oauth/${provider}/start`, {
+        sharing: input?.sharing,
+        ...(input?.resourceLabel === undefined ? {} : { resource_label: input.resourceLabel }),
+        ...(input?.resourceId === undefined ? {} : { resource_id: input.resourceId }),
+    }));
+}
+export async function pollProjectProviderOAuth(projectId, provider, flowId) {
+    return unwrap(await backendApi.post(`/projects/${projectId}/oauth/${provider}/poll`, {
+        flow_id: flowId,
+    }));
+}
+export async function deleteProjectProviderOAuth(projectId, provider) {
+    return unwrap(await backendApi.delete(`/projects/${projectId}/oauth/${encodeURIComponent(provider)}`));
+}
+const POLL_INTERVAL_FLOOR_MS = 2_000;
+const POLL_INTERVAL_FALLBACK_MS = 3_000;
+const POLL_DEADLINE_FALLBACK_MS = 10 * 60_000;
+export async function runProjectProviderOAuthFlow(options) {
+    const { projectId, provider, input, onChallenge, isCancelled, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), now = () => Date.now(), } = options;
+    const cancelled = () => isCancelled?.() ?? false;
+    const start = await startProjectProviderOAuth(projectId, provider, input);
+    if (cancelled())
+        return { status: 'cancelled' };
+    onChallenge?.({ verification_url: start.verification_url, user_code: start.user_code });
+    const interval = Math.max(POLL_INTERVAL_FLOOR_MS, start.interval_ms || POLL_INTERVAL_FALLBACK_MS);
+    const deadline = start.expires_at || now() + POLL_DEADLINE_FALLBACK_MS;
+    while (!cancelled() && now() < deadline) {
+        await sleep(interval);
+        if (cancelled())
+            return { status: 'cancelled' };
+        let poll;
+        try {
+            poll = await pollProjectProviderOAuth(projectId, provider, start.flow_id);
+        }
+        catch {
+            continue;
+        }
+        if (cancelled())
+            return { status: 'cancelled' };
+        if (poll.status === 'success')
+            return { status: 'success', credential: poll.credential };
+        if (poll.status === 'failed')
+            return { status: 'failed', error: poll.error };
+        if (poll.status === 'expired')
+            return { status: 'expired' };
+    }
+    return cancelled() ? { status: 'cancelled' } : { status: 'expired' };
+}
+export async function upsertProjectGitCredential(projectId, input) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/git-credential`, input));
+}
+export async function deleteProjectSecret(projectId, identifier) {
+    return unwrap(await backendApi.delete(`/projects/${projectId}/secrets/${encodeURIComponent(identifier)}`));
+}
+export async function setPersonalProjectSecret(projectId, name, input) {
+    return unwrap(await backendApi.put(`/projects/${projectId}/secrets/${encodeURIComponent(name)}/personal`, input));
+}
+export async function deletePersonalProjectSecret(projectId, name) {
+    return unwrap(await backendApi.delete(`/projects/${projectId}/secrets/${encodeURIComponent(name)}/personal`));
+}

package/dist/core/rest/projects-client/session-attachments.d.ts

@@ -0,0 +1,22 @@
+export interface SessionAttachment {
+    attachment_id: string;
+    filename: string;
+    mime: string;
+    size: number;
+    url: string;
+}
+export declare function isSessionAttachmentRef(value: unknown): boolean;
+export declare function uploadSessionAttachment(projectId: string, sessionId: string, file: File, options?: {
+    attachmentId?: string;
+    signal?: AbortSignal;
+}): Promise<SessionAttachment>;
+export declare function fetchSessionAttachment(ref: string, signal?: AbortSignal): Promise<Blob>;
+export interface SessionAttachmentReference {
+    url: string;
+    attachment_id: string;
+    filename: string | null;
+    mime: string | null;
+    message_id: string;
+    role: string;
+}
+export declare function findSessionAttachments(messages: readonly unknown[]): SessionAttachmentReference[];

package/dist/core/rest/projects-client/session-attachments.js

@@ -0,0 +1,166 @@
+import { normalizeActivityToolName } from "../../turns/segments/session-activity-groups.js";
+import { ApiError, backendApi } from "../../http/api-client.js";
+import { authenticatedFetch } from "../../http/auth.js";
+import { platformConfig } from "../../http/config.js";
+import { unwrap } from "./shared.js";
+const MAX_SESSION_ATTACHMENT_BYTES = 50 * 1024 * 1024;
+const UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+const REFERENCE = new RegExp(`^beeuni-attachment://(${UUID})/(${UUID})/(${UUID})$`);
+function parseSessionAttachmentRef(value) {
+    if (typeof value !== "string")
+        return null;
+    const match = REFERENCE.exec(value);
+    return match
+        ? { projectId: match[1], sessionId: match[2], attachmentId: match[3] }
+        : null;
+}
+export function isSessionAttachmentRef(value) {
+    return parseSessionAttachmentRef(value) !== null;
+}
+const uploads = new WeakMap();
+export async function uploadSessionAttachment(projectId, sessionId, file, options = {}) {
+    if (file.size > MAX_SESSION_ATTACHMENT_BYTES)
+        throw new Error("Attachments must be 50 MiB or smaller.");
+    const key = `${projectId}/${sessionId}`;
+    const cached = options.attachmentId ? undefined : uploads.get(file)?.get(key);
+    if (cached?.promise)
+        return cached.promise;
+    const entry = cached ?? {
+        id: options.attachmentId ?? crypto.randomUUID(),
+        promise: undefined,
+    };
+    if (!options.attachmentId) {
+        const scopes = uploads.get(file) ?? new Map();
+        scopes.set(key, entry);
+        uploads.set(file, scopes);
+    }
+    const form = new FormData();
+    form.append("attachment_id", entry.id);
+    form.append("file", file, file.name);
+    entry.promise = backendApi
+        .upload(`/projects/${encodeURIComponent(projectId)}/sessions/${encodeURIComponent(sessionId)}/attachments`, form, { signal: options.signal, timeout: 120_000, showErrors: false })
+        .then(unwrap)
+        .catch((error) => {
+        entry.promise = undefined;
+        throw error;
+    });
+    return entry.promise;
+}
+export async function fetchSessionAttachment(ref, signal) {
+    const scope = parseSessionAttachmentRef(ref);
+    if (!scope)
+        throw new Error("Invalid attachment reference");
+    const base = platformConfig().backendUrl.replace(/\/$/, "");
+    const response = await authenticatedFetch(`${base}/projects/${scope.projectId}/sessions/${scope.sessionId}/attachments/${scope.attachmentId}`, { signal });
+    if (!response.ok)
+        throw new ApiError("Could not load attachment", {
+            status: response.status,
+        });
+    return response.blob();
+}
+const SHOWN_TOOLS = new Set(["show", "show_user"]);
+function fileTagAttributes(text) {
+    const found = [];
+    let from = 0;
+    for (;;) {
+        const index = text.indexOf("<file", from);
+        if (index === -1)
+            return found;
+        const after = index + "<file".length;
+        if (after >= text.length || !/\s/.test(text[after])) {
+            from = after;
+            continue;
+        }
+        const gt = text.indexOf(">", after);
+        if (gt === -1)
+            return found;
+        const close = text.indexOf("</file>", gt + 1);
+        if (close === -1)
+            return found;
+        found.push(text.slice(after, gt).trimStart());
+        from = close + "</file>".length;
+    }
+}
+const isObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const stringOrNull = (value) => typeof value === "string" && value.length > 0 ? value : null;
+const basename = (value) => typeof value === "string" ? stringOrNull(value.split("/").pop()) : null;
+function tagAttribute(attrs, key) {
+    const value = attrs.match(new RegExp(`(?:^|\\s)${key}="([^"]*)"`))?.[1];
+    if (value === undefined)
+        return null;
+    return value
+        .replace(/&quot;/g, '"')
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&amp;/g, "&");
+}
+function showItems(raw) {
+    if (Array.isArray(raw))
+        return raw;
+    if (typeof raw !== "string" || !raw.trim())
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+function attachmentsFromTextPart(text, add) {
+    for (const attrs of fileTagAttributes(text)) {
+        add(tagAttribute(attrs, "attachment"), tagAttribute(attrs, "filename") ?? basename(tagAttribute(attrs, "path")), tagAttribute(attrs, "mime"));
+    }
+}
+function attachmentsFromToolPart(input, add) {
+    for (const card of [input, ...showItems(input.items)]) {
+        if (isObject(card))
+            add(card.attachment, basename(card.path), null);
+    }
+}
+export function findSessionAttachments(messages) {
+    if (!Array.isArray(messages))
+        return [];
+    const found = [];
+    const seen = new Set();
+    for (const message of messages) {
+        if (!isObject(message) || !isObject(message.info) || !Array.isArray(message.parts))
+            continue;
+        const messageId = stringOrNull(message.info.id);
+        if (!messageId)
+            continue;
+        const role = stringOrNull(message.info.role) ?? "unknown";
+        const add = (url, filename, mime) => {
+            const scope = parseSessionAttachmentRef(url);
+            if (!scope || seen.has(url))
+                return;
+            seen.add(url);
+            found.push({
+                url: url,
+                attachment_id: scope.attachmentId,
+                filename,
+                mime,
+                message_id: messageId,
+                role,
+            });
+        };
+        for (const part of message.parts) {
+            if (!isObject(part))
+                continue;
+            if (part.type === "file") {
+                add(part.url, stringOrNull(part.filename), stringOrNull(part.mime));
+            }
+            else if (part.type === "text" && typeof part.text === "string") {
+                attachmentsFromTextPart(part.text, add);
+            }
+            else if (part.type === "tool" &&
+                typeof part.tool === "string" &&
+                SHOWN_TOOLS.has(normalizeActivityToolName(part.tool)) &&
+                isObject(part.state) &&
+                isObject(part.state.input)) {
+                attachmentsFromToolPart(part.state.input, add);
+            }
+        }
+    }
+    return found;
+}

package/dist/core/rest/projects-client/session-costs.d.ts

@@ -0,0 +1,193 @@
+import type { ProjectSessionStatus } from './sessions.js';
+export type SessionCostOwnerType = 'user' | 'service_account' | 'unknown';
+export interface SessionCostSummary {
+    session_id: string;
+    project_id: string;
+    project_name: string;
+    owner_id: string | null;
+    owner_type: SessionCostOwnerType | null;
+    owner_name: string | null;
+    owner_email: string | null;
+    status: ProjectSessionStatus;
+    created_at: string;
+    updated_at: string;
+    last_activity_at: string | null;
+    llm_cost: number;
+    llm_beeuni_cost: number;
+    llm_provider_cost: number;
+    compute_cost: number;
+    total_cost: number;
+    request_count: number;
+    error_count: number;
+    input_tokens: number;
+    output_tokens: number;
+    cached_tokens: number;
+    cache_write_tokens: number;
+    model_count: number;
+    compute_seconds: number;
+}
+export interface SessionCostModelUsage {
+    provider: string;
+    model: string;
+    request_count: number;
+    error_count: number;
+    input_tokens: number;
+    output_tokens: number;
+    cached_tokens: number;
+    cache_write_tokens: number;
+    cost: number;
+    last_at: string;
+}
+export interface SessionCostLlmLedgerEntry {
+    kind: 'llm';
+    id: string;
+    occurred_at: string;
+    cost: number;
+    provider: string;
+    model: string;
+    request_id: string;
+    status: number;
+    ok: boolean;
+    input_tokens: number;
+    output_tokens: number;
+    cached_tokens: number;
+    cache_write_tokens: number;
+}
+export interface SessionCostComputeLedgerEntry {
+    kind: 'compute';
+    id: string;
+    started_at: string;
+    ended_at: string | null;
+    billed_through_at: string;
+    cost: number;
+    provider: string;
+    state: string;
+    compute_seconds: number;
+    cpu_cores: number;
+    memory_gb: number;
+    disk_gb: number;
+    gpu_count: number;
+}
+export type SessionCostLedgerEntry = SessionCostLlmLedgerEntry | SessionCostComputeLedgerEntry;
+export interface SessionCostDetail extends SessionCostSummary {
+    model_usage: SessionCostModelUsage[];
+    ledger_entries: SessionCostLedgerEntry[];
+}
+export interface SessionCostReconciliation {
+    llm_cost: number;
+    compute_cost: number;
+    total_cost: number;
+    request_count: number;
+    compute_window_count: number;
+    compute_seconds: number;
+}
+export interface SessionCostsPage {
+    sessions: SessionCostSummary[];
+    total: number;
+    limit: number;
+    offset: number;
+    next_offset: number | null;
+    reconciliation: SessionCostReconciliation;
+}
+export interface CostWindowOptions {
+    from?: string;
+    to?: string;
+}
+export type SessionCostSort = 'total_desc' | 'total_asc' | 'recent';
+export type ProjectCostSort = SessionCostSort | 'name_asc';
+export interface ListSessionCostsOptions extends CostWindowOptions {
+    accountId?: string;
+    projectId?: string;
+    ownerId?: string;
+    sort?: SessionCostSort;
+    limit?: number;
+    offset?: number;
+}
+export interface GetSessionCostRecordOptions {
+    accountId?: string;
+    projectId?: string;
+}
+export declare function listSessionCosts(options?: ListSessionCostsOptions): Promise<SessionCostsPage>;
+export declare function getSessionCostRecord(sessionId: string, options?: GetSessionCostRecordOptions): Promise<SessionCostDetail>;
+export interface ProjectCostRow {
+    project_id: string;
+    project_name: string;
+    session_count: number;
+    llm_cost: number;
+    llm_beeuni_cost: number;
+    llm_provider_cost: number;
+    compute_cost: number;
+    total_cost: number;
+    last_activity_at: string | null;
+}
+export interface ProjectCostPage {
+    projects: ProjectCostRow[];
+    total: number;
+    limit: number;
+    offset: number;
+    next_offset: number | null;
+}
+export interface ListCostByProjectOptions extends CostWindowOptions {
+    accountId?: string;
+    sort?: ProjectCostSort;
+    limit?: number;
+    offset?: number;
+}
+export declare function listCostByProject(options?: ListCostByProjectOptions): Promise<ProjectCostPage>;
+export interface CostSummaryTotals {
+    llm_cost: number;
+    llm_beeuni_cost: number;
+    llm_provider_cost: number;
+    compute_cost: number;
+    total_cost: number;
+    request_count: number;
+    compute_seconds: number;
+    session_count: number;
+    project_count: number;
+}
+export interface CostSeriesPoint {
+    day: string;
+    llm_cost: number;
+    compute_cost: number;
+    total_cost: number;
+}
+export interface CostModelRow {
+    provider: string;
+    model: string;
+    cost: number;
+    request_count: number;
+}
+export interface CostSummary {
+    totals: CostSummaryTotals;
+    previous: {
+        total_cost: number;
+    };
+    series: CostSeriesPoint[];
+    models: CostModelRow[];
+}
+export interface GetCostSummaryOptions extends CostWindowOptions {
+    accountId?: string;
+    projectId?: string;
+    sessionId?: string;
+}
+export declare function getCostSummary(options?: GetCostSummaryOptions): Promise<CostSummary>;
+export interface ProjectCostExportOptions extends CostWindowOptions {
+    accountId?: string;
+    projectId?: string;
+    sort?: ProjectCostSort;
+}
+export interface SessionCostExportOptions extends CostWindowOptions {
+    accountId?: string;
+    projectId?: string;
+    ownerId?: string;
+    sort?: SessionCostSort;
+}
+export type CostExportOptions = ProjectCostExportOptions | SessionCostExportOptions;
+export declare function costExportUrl(kind: 'projects', options?: ProjectCostExportOptions): string;
+export declare function costExportUrl(kind: 'sessions', options?: SessionCostExportOptions): string;
+export interface CostExportResult {
+    blob: Blob;
+    rowCap: number | null;
+}
+export declare function fetchCostExportCsv(kind: 'projects', options?: ProjectCostExportOptions): Promise<CostExportResult>;
+export declare function fetchCostExportCsv(kind: 'sessions', options?: SessionCostExportOptions): Promise<CostExportResult>;