@kmlckj/aios-agent-server-sdk 0.0.0-stage → 0.0.2

package/dist/shared/local-task-command-client.d.ts

@@ -0,0 +1,55 @@
+import type { SendLocalTaskMessageRequest, RestartLocalTaskMessageRequest, UpdateLocalTaskPendingMessageRequest, DeleteLocalTaskPendingMessageRequest, ReorderLocalTaskPendingMessagesRequest, LocalTaskApprovalRequest, LocalTaskUserInputRequest } from './local-task-api.js';
+import type { LocalTaskInteraction, LocalTaskPendingMessage } from './local-task-api.js';
+import type { LocalTaskCommand, LocalTaskCommandResult, LocalTaskCommandReply, LocalTaskCommandTargets } from './local-task-command.js';
+export interface LocalTaskCommandTransport {
+    executeCommand(command: LocalTaskCommand): Promise<LocalTaskCommandReply>;
+    getCommand(taskId: string, commandId: string): Promise<LocalTaskCommandReply | null>;
+    getCommandTargets(taskId: string): Promise<LocalTaskCommandTargets>;
+    listInteractions(taskId: string): Promise<LocalTaskInteraction[]>;
+    listPendingMessages(taskId: string): Promise<LocalTaskPendingMessage[]>;
+}
+export declare class CommandAwaitingConfirmation extends Error {
+    readonly commandId: string;
+    constructor(commandId: string);
+}
+export declare function dispatchLocalTaskCommand(api: LocalTaskCommandTransport, command: LocalTaskCommand): Promise<LocalTaskCommandResult>;
+export declare function createLocalTaskCommandClient(transport: () => LocalTaskCommandTransport, createId: () => string, dispatch?: (command: LocalTaskCommand) => Promise<LocalTaskCommandResult>): {
+    sendMessage: (request: SendLocalTaskMessageRequest, identity?: {
+        commandId: string;
+        messageId: string;
+    }) => Promise<{
+        status: string;
+        messageId: string;
+        runId: string;
+    }>;
+    restartFromMessage: (request: RestartLocalTaskMessageRequest) => Promise<{
+        status: string;
+        messageId: string;
+        runId: string;
+    }>;
+    enqueueMessage: (request: SendLocalTaskMessageRequest, identity?: {
+        commandId: string;
+        messageId: string;
+    }) => Promise<{
+        status: string;
+        messageId: string;
+        runId: string;
+    }>;
+    updatePendingMessage: (request: UpdateLocalTaskPendingMessageRequest) => Promise<LocalTaskCommandResult>;
+    deletePendingMessage: (request: DeleteLocalTaskPendingMessageRequest) => Promise<void>;
+    reorderPendingMessages: (request: ReorderLocalTaskPendingMessagesRequest) => Promise<LocalTaskPendingMessage[]>;
+    sendPendingMessageNow: (request: DeleteLocalTaskPendingMessageRequest) => Promise<{
+        status: string;
+        messageId: string;
+        runId: string;
+    }>;
+    startPlan: (taskId: string) => Promise<{
+        status: string;
+        runId: string;
+    }>;
+    cancel: (taskId: string) => Promise<void>;
+    respondToApproval: (request: LocalTaskApprovalRequest) => Promise<void>;
+    submitUserInput: (request: LocalTaskUserInputRequest) => Promise<void>;
+    cancelUserInput: (request: Omit<LocalTaskUserInputRequest, "response">) => Promise<void>;
+};
+export type LocalTaskExecutionCommands = ReturnType<typeof createLocalTaskCommandClient>;

package/dist/shared/local-task-command.d.ts

@@ -0,0 +1,93 @@
+import type { LocalTaskApprovalRequest, LocalTaskInteraction, LocalTaskUserInputRequest, RestartLocalTaskMessageRequest, SendLocalTaskMessageRequest } from './local-task-api.js';
+export declare function matchesTaskInteraction(item: LocalTaskInteraction, kind: 'approve' | 'input' | 'input_cancel', responseId: string): boolean;
+type Header<K extends string, P> = {
+    commandId: string;
+    taskId: string;
+    kind: K;
+    payload: P;
+};
+export type LocalTaskCommand = Header<'send' | 'enqueue', {
+    messageId: string;
+    request: SendLocalTaskMessageRequest;
+}> | Header<'restart', {
+    messageId: string;
+    historyVersion: string;
+    request: RestartLocalTaskMessageRequest;
+}> | Header<'queue_edit', {
+    pendingMessageId: string;
+    queueVersion: string;
+    content: string;
+}> | Header<'queue_delete' | 'queue_send', {
+    pendingMessageId: string;
+    queueVersion: string;
+    targetRunId: string | null;
+}> | Header<'queue_reorder', {
+    pendingMessageIds: string[];
+    queueVersion: string;
+}> | Header<'plan_start', {
+    runId: string;
+    targetRunId: string | null;
+    planRunId?: string;
+}> | Header<'compact', {
+    runId: string;
+    historyVersion: string;
+}> | Header<'cancel', {
+    targetRunId: string;
+    handoff?: boolean;
+}> | Header<'approve', {
+    targetRunId: string;
+    request: LocalTaskApprovalRequest;
+}> | Header<'input', {
+    targetRunId: string;
+    request: LocalTaskUserInputRequest;
+}> | Header<'input_cancel', {
+    targetRunId: string;
+    request: Omit<LocalTaskUserInputRequest, 'response'>;
+}>;
+export type LocalTaskCommandStage = 'preparing' | 'dispatching' | 'runtime_accepted' | 'queued' | 'settled';
+export interface LocalTaskCommandResult {
+    status: string;
+    messageId?: string;
+    runId?: string;
+}
+export type LocalTaskCommandReply = {
+    disposition: 'accepted' | 'duplicate';
+    commandId: string;
+    stage: LocalTaskCommandStage;
+    result: LocalTaskCommandResult;
+} | {
+    disposition: 'reconciling';
+    commandId: string;
+    reasonCode: string;
+} | {
+    disposition: 'rejected';
+    commandId: string;
+    code: 'stale' | 'payload_conflict' | 'invalid' | 'unavailable';
+    causeCode?: string;
+    message?: string;
+};
+/** Internal journal payload. Contains identifiers, never a second copy of the user's prompt. */
+export interface LocalTaskCommandRecord {
+    version: 1;
+    commandId: string;
+    kind: LocalTaskCommand['kind'];
+    fingerprint: string;
+    stage: LocalTaskCommandStage;
+    messageId?: string;
+    targetRunId?: string;
+    restartMessageId?: string;
+    pendingMessageId?: string;
+    interactionId?: string;
+    outcomeFingerprint?: string;
+    result?: LocalTaskCommandResult;
+    rejection?: Extract<LocalTaskCommandReply, {
+        disposition: 'rejected';
+    }>;
+}
+export interface LocalTaskCommandTargets {
+    activeRunId: string | null;
+    planRunId?: string | null;
+    queueVersion: string;
+    historyVersion: string;
+}
+export {};

package/dist/shared/local-task-event-projection.d.ts

@@ -0,0 +1,29 @@
+import type { LocalTaskEvent } from './local-task-api.js';
+export interface LocalTaskTextChunk {
+    id: string;
+    sequence?: number;
+    createdAt: string;
+    text: string;
+}
+export interface LocalTaskTextSpan extends Omit<LocalTaskTextChunk, 'text'> {
+    start: number;
+    end: number;
+}
+export declare function textField(event: LocalTaskEvent): string | undefined;
+export declare function textIdentity(event: LocalTaskEvent): string;
+export declare function taskEventChunks(event: LocalTaskEvent): LocalTaskTextChunk[];
+/** A display projection only. Original journal events and runtime cursors are never rewritten. */
+export declare class LocalTaskEventProjection {
+    private events;
+    private lastIdentity;
+    private ownsLast;
+    private lastSource?;
+    constructor(events?: LocalTaskEvent[]);
+    append(event: LocalTaskEvent, chunk?: LocalTaskTextChunk): void;
+    snapshot(): LocalTaskEvent[];
+}
+export declare function appendProjectedTaskEvents(current: LocalTaskEvent[], incoming: LocalTaskEvent[]): LocalTaskEvent[];
+export declare function projectTaskEvents(events: LocalTaskEvent[]): LocalTaskEvent[];
+export declare function lastDisplayEventId(event: LocalTaskEvent): string;
+/** Resolve overlapping display blocks only; unchanged history never expands into individual deltas. */
+export declare function mergeProjectedTaskEvents(persisted: LocalTaskEvent[], live: LocalTaskEvent[]): LocalTaskEvent[];

package/dist/shared/local-task-projection.d.ts

@@ -0,0 +1,29 @@
+import type { LocalTask, LocalTaskEvent, LocalTaskExecutionState, LocalTaskInteraction, LocalTaskMessagePage, LocalTaskPendingMessage } from './local-task-api.js';
+export interface LocalTaskStateCursor {
+    publisherEpoch: string;
+    revision: number;
+}
+export interface LocalTaskSnapshot {
+    task: LocalTask;
+    messages: LocalTaskMessagePage;
+    pendingMessages: LocalTaskPendingMessage[];
+    interactions: LocalTaskInteraction[];
+    execution: LocalTaskExecutionState;
+    /** Current unfinished assistant item; persisted messages remain the history authority. */
+    assistantStream?: {
+        runId: string;
+        itemId?: string;
+        content: string;
+    };
+    cursor: LocalTaskStateCursor;
+}
+export interface LocalTaskStateBatch {
+    taskId: string;
+    subscriptionId: string;
+    publisherEpoch: string;
+    fromRevision: number;
+    toRevision: number;
+    events: LocalTaskEvent[];
+    resnapshot: boolean;
+}
+export declare function classifyStateBatch(cursor: LocalTaskStateCursor, batch: LocalTaskStateBatch): 'apply' | 'duplicate' | 'resnapshot';

package/dist/shared/local-workspace.d.ts

@@ -0,0 +1,9 @@
+/** A user-selected local directory, independent of tasks and environment files. */
+export interface LocalWorkspace {
+    id: string;
+    ownerUserId: string;
+    ownerPlatformUrl?: string;
+    rootPath: string;
+    name: string;
+    selectedEnvironmentId?: string;
+}

package/dist/shared/managed-authorization.d.ts

@@ -0,0 +1,72 @@
+import type { AuthSession } from './desktop-api.js';
+import type { ExecutionBinding } from './execution-context.js';
+export interface ManagedPrincipal {
+    userId: string;
+    tenantId: string | null;
+    workspaceId: string | null;
+}
+export interface ManagedAuthentication {
+    kind: 'managed';
+    principal: ManagedPrincipal;
+    /** Additional origins allowed to receive platform credentials. The platform origin is always included. */
+    allowedOrigins?: string[];
+}
+export interface ManagedCredential {
+    accessToken: string;
+    session: AuthSession;
+}
+export type CredentialReason = 'initial' | 'expiring' | 'rejected' | 'explicit';
+export interface ManagedCredentialRequest {
+    reason: CredentialReason;
+    signal: AbortSignal;
+    /** Trusted run identity. Absent for instance-level platform management requests. */
+    execution?: Readonly<ExecutionBinding>;
+}
+export type CredentialProvider = (request: ManagedCredentialRequest) => Promise<ManagedCredential | null>;
+export interface ManagedAuthorizationEvent {
+    cursor: string;
+    occurredAt: string;
+    type: 'authorized' | 'invalidated';
+    scope: 'credential' | 'provider';
+    reason: CredentialReason | 'expired' | 'revoked' | 'provider_error' | 'closed';
+    execution?: ExecutionBinding;
+    expiresAt?: string;
+    code?: string;
+}
+/** Private process transport metadata, never a platform access/refresh token. */
+export interface CredentialConnection {
+    url: string;
+    token: string;
+}
+export interface ManagedAuthorizationConnection extends CredentialConnection {
+    handle: string;
+    platformBaseUrl: string;
+    principal: ManagedPrincipal;
+    allowedOrigins: string[];
+    /** Resolved from authenticated platform model details, keyed by model code. */
+    configuredModelOrigins?: Record<string, string[]>;
+}
+export interface AuthorizedPlatformContext {
+    accessToken: string;
+    sessionId: string | null;
+    platformBaseUrl: string;
+    tenantId: string | null;
+    userId: string | null;
+    workspaceId: string | null;
+}
+export interface ManagedAuthorizationSource {
+    getSession(): AuthSession | null;
+    authorize(): Promise<AuthorizedPlatformContext>;
+    refresh(): Promise<AuthSession>;
+    invalidate(reason: string): Promise<void>;
+}
+export declare function authorizationError(code: string, message: string): Error & {
+    code: string;
+};
+export declare function validateManagedAuthentication(value: ManagedAuthentication, platformBaseUrl: string): ManagedAuthentication;
+export declare function validateCredentialConnection(value: CredentialConnection): CredentialConnection;
+export declare function validateManagedCredential(value: ManagedCredential, principal: ManagedPrincipal, platformBaseUrl: string, now?: number): {
+    credential: ManagedCredential;
+    expiresAt: number;
+    sessionId: string | null;
+};

package/dist/shared/memory-customization.d.ts

@@ -0,0 +1,32 @@
+import type { MemoryRecord, MemoryScope, MemoryState } from './local-memory.js';
+export interface MemoryExtractionPolicy {
+    enabled?: boolean;
+    idleMs?: number;
+    model?: string;
+    instructions?: string;
+    timeoutMs?: number;
+}
+export interface MemoryConfiguration {
+    storage?: 'local' | 'external';
+    extraction?: MemoryExtractionPolicy;
+}
+export interface MemorySnapshot {
+    state: MemoryState;
+    records: MemoryRecord[];
+}
+export interface MemoryStoreAdapter {
+    read(scope: Readonly<MemoryScope>, signal?: AbortSignal): Promise<{
+        version: string;
+        snapshot: MemorySnapshot;
+    } | null>;
+    /** Atomic compare-and-swap; a conflict must throw, never overwrite a newer revision. */
+    compareAndSwap(request: {
+        scope: Readonly<MemoryScope>;
+        expectedVersion: string | null;
+        snapshot: MemorySnapshot;
+        operationId: string;
+    }, signal?: AbortSignal): Promise<{
+        version: string;
+    }>;
+}
+export declare function validateMemoryConfiguration(value?: MemoryConfiguration): void;

package/dist/shared/model-routing.d.ts

@@ -0,0 +1,31 @@
+import type { ExecutionBinding } from './execution-context.js';
+export interface ModelRoutingIdentity {
+    executionBinding?: ExecutionBinding;
+    currentUserId?: string;
+    currentUserName?: string;
+    currentOrgId?: string;
+    currentOrgName?: string;
+    ownerProjectId?: string;
+    ownerProjectName?: string;
+    ownerProjectType?: string;
+    ownerApplicationType?: string;
+    ownerWorkspaceId?: string;
+    ownerWorkspaceName?: string;
+    ownerOrgId?: string;
+    ownerOrgName?: string;
+    ownerUserId?: string;
+    ownerUserName?: string;
+    ownerWorkflowId?: string;
+    ownerWorkflowName?: string;
+    ownerPluginId?: string;
+    ownerPluginName?: string;
+    runtimeEnv?: string;
+    usageScene?: string;
+    /** @deprecated Use ownerWorkspaceId for new requests. */
+    workspaceId?: string;
+}
+export declare const LICOS_MODEL_ROUTING_HEADER_NAMES: readonly ["X-Licos-Current-User-Id", "X-Licos-Current-User-Name", "X-Licos-Current-Org-Id", "X-Licos-Current-Org-Name", "X-Licos-Owner-Project-Id", "X-Licos-Owner-Project-Name", "X-Licos-Owner-Project-Type", "X-Licos-Owner-Application-Type", "X-Licos-Owner-Workspace-Id", "X-Licos-Owner-Workspace-Name", "X-Licos-Owner-Org-Id", "X-Licos-Owner-Org-Name", "X-Licos-Owner-User-Id", "X-Licos-Owner-User-Name", "X-Licos-Owner-Workflow-Id", "X-Licos-Owner-Workflow-Name", "X-Licos-Owner-Plugin-Id", "X-Licos-Owner-Plugin-Name", "X-Licos-Runtime-Env", "X-Licos-UsagScene"];
+export declare function encodeLicosHeaderValue(name: string, value: string): string;
+export declare function modelRoutingHeaders(identity: ModelRoutingIdentity, usageScene?: string | undefined): {
+    'X-AIOS-Execution-Context'?: string | undefined;
+};

package/dist/shared/model-selection.d.ts

@@ -0,0 +1,11 @@
+export declare const DEFAULT_LOCAL_TASK_CONTEXT_WINDOW: number;
+export type ModelReasoningEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+export interface ModelReasoningConfig {
+    mode: 'disabled' | 'optional' | 'required';
+    efforts: ModelReasoningEffort[];
+    defaultEffort: ModelReasoningEffort | null;
+    xhighEffort: 'xhigh' | 'max' | null;
+}
+export declare function isModelReasoningEffort(value: unknown): value is ModelReasoningEffort;
+export declare function parseModelReasoningEffort(value: unknown): ModelReasoningEffort | undefined;
+export declare function parseModelThinkingEnabled(value: unknown): boolean | undefined;

package/dist/shared/my-expert-api.d.ts

@@ -0,0 +1,119 @@
+import type { ExpertTeamRunSnapshot } from './expert-team-api.js';
+import type { LocalTaskProfessionReference } from './local-task-api.js';
+export type MyExpertType = 'agent' | 'team';
+export interface ExpertResourceMapping {
+    reference: string;
+    folderName: string;
+    sha256: string;
+}
+export interface MyExpertManifest {
+    schemaVersion: 1;
+    packageFormat: 'aios-expert';
+    name: string;
+    version: string;
+    expertType: MyExpertType;
+    agentName: string;
+    displayName: string;
+    displayDescription: string;
+    description: string;
+    profession: string;
+    avatar: string;
+    agents: string | string[];
+    tags: [string, string, string];
+    quickPrompts: [string, string, string];
+    teamInfo?: {
+        leadAgent: string;
+        memberAgents: string[];
+    };
+    members?: Array<{
+        id: string;
+        role: 'lead' | 'member';
+        avatar: string;
+        displayName: string;
+        profession: string;
+    }>;
+    skills?: string[];
+}
+export interface MyExpertAgentDefinition {
+    id: string;
+    displayName: string;
+    profession: string;
+    description: string;
+    instructions: string;
+    maxTurns: number | null;
+    skills: string[];
+    role: 'lead' | 'member';
+    avatarRelativePath: string;
+}
+export interface MyExpertSummary {
+    expertId: string;
+    version: string;
+    expertType: MyExpertType;
+    displayName: string;
+    alias: string;
+    profession: string;
+    description: string;
+    tags: [string, string, string];
+    avatarDataUrl: string | null;
+    memberCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface MyExpertDetail extends MyExpertSummary {
+    quickPrompts: [string, string, string];
+    agents: MyExpertAgentDefinition[];
+    packagePath: string;
+}
+export interface ListMyExpertsQuery {
+    expertType?: MyExpertType;
+    keyword?: string;
+}
+export interface MyExpertPublishResult {
+    expertId: string;
+    version: string;
+    expertType: MyExpertType;
+    created: boolean;
+    contentHash: string;
+}
+export interface MyExpertAuthoringAgent {
+    id: string;
+    displayName: string;
+    profession: string;
+    description: string;
+    instructions: string;
+    maxTurns: number;
+    skills: string[];
+}
+export interface MyExpertAuthoringDraft {
+    name: string;
+    version: string;
+    expertType: MyExpertType;
+    displayName: string;
+    displayDescription: string;
+    description: string;
+    profession: string;
+    tags: [string, string, string];
+    quickPrompts: [string, string, string];
+    leadAgent: string;
+    agents: MyExpertAuthoringAgent[];
+}
+export interface MyExpertApi {
+    list: (query?: ListMyExpertsQuery) => Promise<MyExpertSummary[]>;
+    get: (expertId: string) => Promise<MyExpertDetail>;
+    prepareForLocalTask: (expertId: string) => Promise<LocalTaskProfessionReference>;
+    openDirectory: (expertId: string) => Promise<void>;
+    remove: (expertId: string) => Promise<void>;
+    onChanged: (listener: () => void) => () => void;
+}
+export interface ValidatedMyExpertPackage {
+    manifest: MyExpertManifest;
+    files: Array<{
+        relativePath: string;
+        absolutePath: string;
+        sizeBytes: number;
+    }>;
+    contentHash: string;
+    agent: MyExpertAgentDefinition | null;
+    agents: MyExpertAgentDefinition[];
+    teamSnapshot: ExpertTeamRunSnapshot | null;
+}

package/dist/shared/navigation-api.d.ts

@@ -0,0 +1,20 @@
+export type ProtocolTarget = {
+    kind: 'external';
+    url: string;
+} | {
+    kind: 'app';
+    resourceType: string;
+    resourceId: string;
+} | {
+    kind: 'page';
+    path: string;
+};
+export interface InAppBrowserTarget {
+    url: string;
+    title?: string;
+}
+export interface NavigationApi {
+    openExternal(url: string): Promise<void>;
+    resolveInAppTarget(target: ProtocolTarget): Promise<InAppBrowserTarget>;
+    openProtocolTarget(target: ProtocolTarget): Promise<void>;
+}

package/dist/shared/office-window-api.d.ts

@@ -0,0 +1,81 @@
+import type { DocumentEdit, DocumentEditorVersion, DocumentSelection } from './document-session-api.js';
+export interface OfficeEditorRequest {
+    requestId: string;
+    documentId: string;
+    action: 'snapshot' | 'apply' | 'save';
+    expectedEditorRevision?: number;
+    expectedDiskRevision?: string;
+    edit?: DocumentEdit;
+}
+export interface OfficeEditorResponse {
+    requestId: string;
+    result?: {
+        version: DocumentEditorVersion;
+        selection: DocumentSelection | null;
+        data?: Uint8Array;
+    };
+    error?: string;
+}
+export interface OfficeDocument {
+    id: string;
+    filePath: string;
+    name: string;
+    revision: string;
+    sizeBytes: number;
+}
+export interface OfficeDocumentContent extends OfficeDocument {
+    data: Uint8Array;
+}
+export interface OfficeWindowSnapshot {
+    documents: OfficeDocument[];
+    activeDocumentId: string | null;
+    recentFiles: string[];
+}
+export type OfficeMainSection = 'skills' | 'plugins' | 'experts';
+export interface OfficeWindowApi {
+    openTaskEditor(request: import('./local-task-api.js').LocalTaskFileRequest): Promise<OfficeDocumentContent>;
+    readTaskEditor(id: string): Promise<OfficeDocumentContent>;
+    saveTaskEditor(request: {
+        id: string;
+        data: Uint8Array;
+        expectedRevision: string;
+    }): Promise<OfficeDocument>;
+    closeTaskEditor(id: string): Promise<void>;
+    onTaskEditorFileChanged(listener: (id: string) => void): () => void;
+    respondTaskEditor(request: {
+        documentId: string;
+        response: OfficeEditorResponse;
+    }): Promise<void>;
+    openTaskFile(request: import('./local-task-api.js').LocalTaskFileRequest): Promise<void>;
+    focusTaskFile(request: import('./local-task-api.js').LocalTaskFileRequest): Promise<boolean>;
+    isTaskFileOpen(request: import('./local-task-api.js').LocalTaskFileRequest): Promise<boolean>;
+    onDocumentsChanged(listener: () => void): () => void;
+    openFiles(request: {
+        paths: string[];
+    }): Promise<void>;
+    chooseFiles(): Promise<void>;
+    createDocument(extension: 'txt' | 'md' | 'docx' | 'xlsx' | 'pptx'): Promise<void>;
+    getSnapshot(): Promise<OfficeWindowSnapshot>;
+    consumeErrors(): Promise<string[]>;
+    onErrors(listener: () => void): () => void;
+    readDocument(id: string): Promise<OfficeDocumentContent>;
+    saveDocument(request: {
+        id: string;
+        data: Uint8Array;
+        expectedRevision: string;
+    }): Promise<OfficeDocument>;
+    setDirty(request: {
+        id: string;
+        dirty: boolean;
+    }): Promise<void>;
+    activateDocument(id: string): Promise<void>;
+    closeDocument(id: string): Promise<boolean>;
+    revealDocument(id: string): Promise<void>;
+    openMainWindow(section?: OfficeMainSection): Promise<void>;
+    consumeMainNavigation(): Promise<OfficeMainSection | null>;
+    onMainNavigation(listener: () => void): () => void;
+    onChanged(listener: (snapshot: OfficeWindowSnapshot) => void): () => void;
+    onFileChanged(listener: (id: string) => void): () => void;
+    onEditorRequest(listener: (request: OfficeEditorRequest) => void): () => void;
+    respondEditor(response: OfficeEditorResponse): Promise<void>;
+}

package/dist/shared/platform-branding-api.d.ts

@@ -0,0 +1,66 @@
+export interface PlatformBrandingIdentity {
+    brandName: string;
+    brandShortName: string;
+    productPrimaryName: string;
+    productSecondaryName: string;
+    platformDisplayName: string;
+    siteTitle: string;
+    siteDescription: string;
+    companyLegalName: string;
+    officialPublisherName: string;
+}
+export interface PlatformBrandingAssets {
+    logoLightUrl: string;
+    logoDarkUrl: string;
+    compactLogoLightUrl: string;
+    compactLogoDarkUrl: string;
+    faviconUrl: string;
+    appleTouchIconUrl: string;
+    shareImageUrl: string;
+    portalHeroBackgroundUrl: string;
+    productArchitectureImageUrl: string;
+    officialAccountQrUrl: string;
+    videoAccountQrUrl: string;
+}
+export interface PlatformBrandingContact {
+    phone: string;
+    phoneDescription: string;
+    email: string;
+    address: string;
+}
+export interface PlatformBrandingLinks {
+    documentationUrl: string;
+    termsUrl: string;
+    privacyUrl: string;
+    dataProcessingUrl: string;
+}
+export interface PlatformBrandingLegal {
+    copyrightText: string;
+    icpNumber: string;
+    icpUrl: string;
+    publicSecurityNumber: string;
+    publicSecurityUrl: string;
+}
+export interface PlatformBrandingProducts {
+    codingDisplayName: string;
+    codingWelcomeTitle: string;
+    desktopClientName: string;
+    mobileClientName: string;
+    adminConsoleName: string;
+}
+export interface PlatformBrandingValues {
+    identity: PlatformBrandingIdentity;
+    assets: PlatformBrandingAssets;
+    contact: PlatformBrandingContact;
+    links: PlatformBrandingLinks;
+    legal: PlatformBrandingLegal;
+    products: PlatformBrandingProducts;
+}
+export interface PublicPlatformBranding {
+    version: number;
+    publishedAt?: string;
+    values: PlatformBrandingValues;
+}
+export interface PlatformBrandingApi {
+    getCurrent(): Promise<PublicPlatformBranding>;
+}