@dxs-ts/eveli-ide 0.0.7 → 0.0.12

package/build/index.d.ts

@@ -1,27 +1,361 @@
 import { default as default_2 } from 'react';
 import { Theme } from '@mui/material/styles';
 
-declare class DefaultStore implements Store {
+declare class DefaultStore implements HdesApi.Store {
     private _config;
     private _updateStarted;
     private _iapSessionRefreshWindow;
     private _defRef;
-    constructor(config: StoreConfig);
+    constructor(config: HdesApi.StoreConfig);
     iapRefresh(): Promise<void>;
     iapLogin(): boolean;
     handle401(): Promise<void>;
     fetch<T>(path: string, req?: RequestInit): Promise<T>;
 }
 
-declare interface ServiceErrorMsg {
-    id: string;
-    value: string;
-}
-
-declare interface ServiceErrorProps {
-    text: string;
-    status: number;
-    errors: ServiceErrorMsg[];
+declare namespace HdesApi {
+    type TagId = string;
+    type EntityId = string;
+    type FlowId = string;
+    type ServiceId = string;
+    type DecisionId = string;
+    type BranchId = string;
+    type AstBodyType = "FLOW" | "FLOW_TASK" | "DT" | "TAG" | "BRANCH";
+    type Direction = "IN" | "OUT";
+    type ValueType = "TIME" | "DATE" | "DATE_TIME" | "INSTANT" | "PERIOD" | "DURATION" | "STRING" | "INTEGER" | "LONG" | "BOOLEAN" | "PERCENT" | "OBJECT" | "ARRAY" | "DECIMAL" | "MAP" | "FLOW_CONTEXT";
+    type ProgramStatus = "UP" | "AST_ERROR" | "PROGRAM_ERROR" | "DEPENDENCY_ERROR";
+    type HitPolicy = "FIRST" | "ALL";
+    type AssociationType = "ONE_TO_ONE" | "ONE_TO_MANY";
+    type ColumnExpressionType = "IN" | "EQUALS";
+    type FlowCommandMessageType = "ERROR" | "WARNING";
+    type AstCommandValue = ("SET" | "ADD" | "DELETE" | "SET_BODY" | "SET_NAME" | "SET_DESCRIPTION" | "IMPORT_CSV" | "IMPORT_ORDERED_CSV" | "MOVE_ROW" | "MOVE_HEADER" | "INSERT_ROW" | "COPY_ROW" | "SET_HEADER_TYPE" | "SET_HEADER_REF" | "SET_HEADER_NAME" | "SET_HEADER_SCRIPT" | "SET_HEADER_DIRECTION" | "SET_HEADER_EXPRESSION" | "SET_HIT_POLICY" | "SET_CELL_VALUE" | "DELETE_CELL" | "DELETE_HEADER" | "DELETE_ROW" | "ADD_LOG" | "ADD_HEADER_IN" | "ADD_HEADER_OUT" | "ADD_ROW" | "SET_VALUE_SET" | "CREATE_BRANCH" | "SET_BRANCH_NAME" | "SET_BRANCH_TAG" | "SET_BRANCH_CREATED");
+    interface CommandsAndChanges {
+        commands: AstCommand[];
+        src: AstChangeset[];
+    }
+    interface AstChangeset {
+        line: number;
+        value: string;
+        commands: AstCommand[];
+    }
+    interface ProgramMessage {
+        id: string;
+        msg: string;
+    }
+    interface AstCommand {
+        id?: string;
+        value?: string;
+        type: AstCommandValue;
+    }
+    interface TypeDef {
+        id: string;
+        name: string;
+        order: number;
+        data: boolean;
+        direction: Direction;
+        valueType: ValueType;
+        required: boolean;
+        properties: TypeDef[];
+        values?: string;
+        valueSet?: string[];
+    }
+    interface AstBody {
+        name: string;
+        description?: string;
+        headers: Headers;
+        bodyType: AstBodyType;
+    }
+    interface Headers {
+        acceptDefs: TypeDef[];
+        returnDefs: TypeDef[];
+    }
+    interface AstSource {
+        id: string;
+        hash: string;
+        bodyType: AstBodyType;
+        commands: AstCommand[];
+    }
+    interface ProgramAssociation {
+        id?: string;
+        ref: string;
+        refType: AstBodyType;
+        refStatus: ProgramStatus;
+        owner: string;
+    }
+    interface Site {
+        name: string;
+        contentType: "OK" | "NOT_CREATED" | "EMPTY" | "ERRORS" | "NO_CONNECTION";
+        tags: Record<TagId, Entity<AstTag>>;
+        flows: Record<FlowId, Entity<AstFlow>>;
+        services: Record<ServiceId, Entity<AstService>>;
+        decisions: Record<DecisionId, Entity<AstDecision>>;
+        branches: Record<BranchId, Entity<AstBranch>>;
+    }
+    interface Entity<A extends AstBody> {
+        id: EntityId;
+        ast?: A;
+        source: AstSource;
+        warnings: ProgramMessage[];
+        errors: ProgramMessage[];
+        associations: ProgramAssociation[];
+        status: ProgramStatus;
+    }
+    interface AstDecision extends AstBody {
+        headerTypes: string[];
+        headerExpressions: Record<ValueType, string[]>;
+        hitPolicy: HitPolicy;
+        rows: AstDecisionRow[];
+    }
+    interface AstDecisionRow {
+        id: string;
+        order: number;
+        cells: AstDecisionCell[];
+    }
+    interface AstDecisionCell {
+        id: string;
+        header: string;
+        value?: string;
+    }
+    interface AstFlow extends AstBody {
+        src: AstFlowRoot;
+        messages: FlowAstCommandMessage[];
+    }
+    interface FlowAstCommandMessage {
+        line: number;
+        value: string;
+        type: FlowCommandMessageType;
+        range?: FlowAstCommandRange;
+    }
+    interface FlowAstCommandRange {
+        start: number;
+        end: number;
+    }
+    interface AstFlowInputType {
+        name: string;
+        value: string;
+        ref?: string;
+    }
+    interface AstFlowRoot extends AstFlowNode {
+        id: AstFlowNode;
+        description: AstFlowNode;
+        types: AstFlowInputType[];
+        inputs: Record<string, AstFlowInputNode>;
+        tasks: Record<string, AstFlowTaskNode>;
+    }
+    interface AstFlowTaskNode extends Omit<AstFlowNode, "switch"> {
+        id: AstFlowNode;
+        order: number;
+        then: AstFlowNode;
+        ref: AstFlowRefNode;
+        userTask: AstFlowRefNode;
+        decisionTable: AstFlowRefNode;
+        service: AstFlowRefNode;
+        switch: Record<string, AstFlowSwitchNode>;
+    }
+    interface AstFlowRefNode extends AstFlowNode {
+        ref: AstFlowNode;
+        collection: AstFlowNode;
+        inputsNode: AstFlowNode;
+        inputs: Record<string, AstFlowNode>;
+    }
+    interface AstFlowSwitchNode extends AstFlowNode {
+        order: string;
+        when: AstFlowNode;
+        then: AstFlowNode;
+    }
+    interface AstFlowInputNode extends AstFlowNode {
+        required: AstFlowNode;
+        type: AstFlowNode;
+        debugValue: AstFlowNode;
+    }
+    interface AstFlowNode {
+        parent: AstFlowNode;
+        keyword: string;
+        children: Record<string, AstFlowNode>;
+        value: string;
+        source: AstChangeset;
+        start: number;
+        end: number;
+        service?: AstFlowNode | undefined;
+        decisionTable?: AstFlowNode | undefined;
+        then?: AstFlowNode | undefined;
+        id?: AstFlowNode | undefined;
+        switch?: AstFlowNode | undefined;
+    }
+    interface AstService extends AstBody {
+        executorType: "TYPE_0" | "TYPE_1" | "TYPE_2";
+        value: string;
+    }
+    interface AstTag extends AstBody {
+        name: string;
+        created: string;
+        values: AstTagValue[];
+    }
+    interface AstTagValue {
+        hash: string;
+        bodyType: AstBodyType;
+        commands: AstCommand[];
+    }
+    interface AstBranch extends AstBody {
+        name: string;
+        created: string;
+        tagId: string;
+    }
+    interface ServiceErrorMsg {
+        id: string;
+        value: string;
+    }
+    interface ServiceErrorProps {
+        text: string;
+        status: number;
+        errors: ServiceErrorMsg[];
+    }
+    interface DebugRequest {
+        id: string;
+        input?: string;
+        inputCSV?: string;
+    }
+    interface DebugResponse {
+        id: string;
+        body?: ProgramResult;
+        bodyCsv?: string;
+    }
+    interface ProgramResult {
+    }
+    interface ServiceResult extends ProgramResult {
+        value: any;
+    }
+    interface DecisionResult extends ProgramResult {
+        rejections: DecisionLog[];
+        matches: DecisionLog[];
+    }
+    interface DecisionLog {
+        match: boolean;
+        order: number;
+        accepts: DecisionLogEntry[];
+        returns: DecisionLogEntry[];
+    }
+    interface DecisionLogEntry {
+        match: boolean;
+        headerType: TypeDef;
+        expression: string;
+        usedValue?: any;
+    }
+    type FlowProgramStepPointerType = "SWITCH" | "THEN" | "END";
+    type FlowProgramStepRefType = "SERVICE" | "DT";
+    type FlowExecutionStatus = "COMPLETED" | "ERROR";
+    interface FlowResult extends ProgramResult {
+        stepId: string;
+        shortHistory: string;
+        logs: FlowResultLog[];
+        status: FlowExecutionStatus;
+        accepts: Record<string, any>;
+        returns: Record<string, any>;
+    }
+    interface FlowResultLog {
+        id: number;
+        stepId: string;
+        start: string | Date;
+        end: string | Date;
+        errors: FlowResultErrorLog[];
+        status: FlowExecutionStatus;
+        accepts: Record<string, any>;
+        returns: Record<string, any>;
+    }
+    interface FlowResultErrorLog {
+        id: string;
+        msg: string;
+    }
+    interface Input {
+        name: string | null | undefined;
+        value: string | null | undefined;
+    }
+    interface Output {
+        name: string | null | undefined;
+        value: string | null | undefined;
+    }
+    interface CsvRow {
+        id: string;
+        inputs: Input[];
+        outputs: Output[];
+    }
+    interface CreateBuilder {
+        site(): Promise<Site>;
+        importData(init: string): Promise<Site>;
+        tag(props: {
+            name: string;
+            desc: string;
+        }): Promise<Site>;
+        flow(name: string): Promise<Site>;
+        service(name: string): Promise<Site>;
+        decision(name: string): Promise<Site>;
+        branch(body: AstCommand[]): Promise<Site>;
+    }
+    interface DeleteBuilder {
+        tag(tagId: TagId): Promise<Site>;
+        flow(flowId: FlowId): Promise<Site>;
+        service(serviceId: ServiceId): Promise<Site>;
+        decision(decisionId: DecisionId): Promise<Site>;
+        branch(branchId: BranchId): Promise<Site>;
+    }
+    interface DiffRequest {
+        baseId: string;
+        targetId: string;
+    }
+    interface DiffResponse {
+        baseName: string;
+        targetName: string;
+        baseId: string;
+        targetId: string;
+        created: string;
+        body: string;
+    }
+    interface AstTagSummaryEntity {
+        id: string;
+        name: string;
+        body: string;
+    }
+    interface AstTagSummary {
+        tagName: string;
+        flows: AstTagSummaryEntity[];
+        services: AstTagSummaryEntity[];
+        decisions: AstTagSummaryEntity[];
+    }
+    interface VersionEntity {
+        version: string;
+        built: string;
+    }
+    interface Service {
+        withBranch(branchName?: string): Service;
+        branch: string | undefined;
+        delete(): DeleteBuilder;
+        create(): CreateBuilder;
+        update(id: string, body: AstCommand[]): Promise<Site>;
+        ast(id: string, body: AstCommand[]): Promise<Entity<any>>;
+        debug(input: DebugRequest): Promise<DebugResponse>;
+        getSite(): Promise<Site>;
+        copy(id: string, name: string): Promise<Site>;
+        version(): Promise<VersionEntity>;
+        diff(input: DiffRequest): Promise<DiffResponse>;
+        summary(tagId: string): Promise<AstTagSummary>;
+    }
+    interface Store {
+        fetch<T>(path: string, init?: RequestInit): Promise<T>;
+    }
+    interface StoreError extends Error {
+        text: string;
+        status: number;
+        errors: ServiceErrorMsg[];
+    }
+    interface StoreConfig {
+        url: string;
+        oidc?: string;
+        status?: string;
+        csrf?: {
+            key: string;
+            value: string;
+        };
+    }
 }
 
 export declare const siteTheme: Theme;
@@ -316,60 +650,45 @@ export declare const stencilIntl: {
     [key: string]: any;
 };
 
-declare interface Store {
-    fetch<T>(path: string, init?: RequestInit): Promise<T>;
-}
-
-declare interface StoreConfig {
-    url: string;
-    oidc?: string;
-    status?: string;
-    csrf?: {
-        key: string;
-        value: string;
-    };
-}
-
 declare class StoreErrorImpl extends Error {
     private _props;
-    constructor(props: ServiceErrorProps);
+    constructor(props: HdesApi.ServiceErrorProps);
     get name(): string;
     get status(): number;
-    get errors(): ServiceErrorMsg[];
+    get errors(): HdesApi.ServiceErrorMsg[];
 }
 
 export declare namespace WrenchClient {
-    export declare type { TagId, FlowId, ServiceId, DecisionId, AstBodyType, Direction, ValueType, ProgramStatus, HitPolicy, AssociationType, ColumnExpressionType, FlowCommandMessageType, AstCommandValue, CommandsAndChanges, AstChangeset, ProgramMessage, AstCommand, TypeDef, AstBody, Headers, AstSource, ProgramAssociation, Site, Entity, EntityId, CreateBuilder, DeleteBuilder, AstDecision, AstDecisionRow, AstDecisionCell, AstFlow, FlowAstCommandMessage, FlowAstCommandRange, AstFlowInputType, AstFlowRoot, AstFlowTaskNode, AstFlowRefNode, AstFlowSwitchNode, AstFlowInputNode, AstFlowNode, AstService, AstTag, AstTagValue, AstBranch, ServiceErrorMsg, ServiceErrorProps, Service, Store, StoreError, StoreConfig, DebugRequest, DebugResponse, ProgramResult, ServiceResult, DecisionResult, DecisionLog, DecisionLogEntry, FlowProgramStepPointerType, FlowProgramStepRefType, FlowExecutionStatus, FlowResult, FlowResultLog, FlowResultErrorLog, Input, Output, CsvRow, VersionEntity, DiffRequest, DiffResponse, AstTagSummaryEntity, AstTagSummary };
 }
 
 export declare namespace WrenchClient {
     const StoreErrorImpl: typeof StoreErrorImpl;
     const StoreImpl: typeof DefaultStore;
-    export class ServiceImpl implements WrenchClient.Service {
+    export class ServiceImpl implements HdesApi.Service {
         private _store;
         private _branch;
         private _headers;
-        constructor(store: WrenchClient.Store, branchName?: string);
-        withBranch(branchName?: string): WrenchClient.ServiceImpl;
+        constructor(store: HdesApi.Store, branchName?: string);
+        withBranch(branchName?: string): ServiceImpl;
         get branch(): string | undefined;
-        create(): WrenchClient.CreateBuilder;
-        delete(): WrenchClient.DeleteBuilder;
-        update(id: string, body: WrenchClient.AstCommand[]): Promise<WrenchClient.Site>;
-        createAsset(name: string, desc: string | undefined, type: WrenchClient.AstBodyType | "SITE", body?: WrenchClient.AstCommand[]): Promise<WrenchClient.Site>;
-        ast(id: string, body: WrenchClient.AstCommand[]): Promise<WrenchClient.Entity<any>>;
-        getSite(): Promise<WrenchClient.Site>;
-        debug(debug: WrenchClient.DebugRequest): Promise<WrenchClient.DebugResponse>;
-        copy(id: string, name: string): Promise<WrenchClient.Site>;
-        version(): Promise<WrenchClient.VersionEntity>;
-        diff(input: WrenchClient.DiffRequest): Promise<WrenchClient.DiffResponse>;
-        summary(tagId: string): Promise<WrenchClient.AstTagSummary>;
+        create(): HdesApi.CreateBuilder;
+        delete(): HdesApi.DeleteBuilder;
+        update(id: string, body: HdesApi.AstCommand[]): Promise<HdesApi.Site>;
+        createAsset(name: string, desc: string | undefined, type: HdesApi.AstBodyType | "SITE", body?: HdesApi.AstCommand[]): Promise<HdesApi.Site>;
+        ast(id: string, body: HdesApi.AstCommand[]): Promise<HdesApi.Entity<any>>;
+        getSite(): Promise<HdesApi.Site>;
+        debug(debug: HdesApi.DebugRequest): Promise<HdesApi.DebugResponse>;
+        copy(id: string, name: string): Promise<HdesApi.Site>;
+        version(): Promise<HdesApi.VersionEntity>;
+        diff(input: HdesApi.DiffRequest): Promise<HdesApi.DiffResponse>;
+        summary(tagId: string): Promise<HdesApi.AstTagSummary>;
     }
 }
 
 export declare const WrenchComposer: default_2.FC<WrenchComposerProps>;
 
 declare interface WrenchComposerProps {
-    service: WrenchClient.Service;
+    service: HdesApi.Service;
     locked?: boolean;
 }
 
@@ -381,13 +700,13 @@ export { }
 
 
 declare namespace Burger {
-    const Provider: import("react").FC<AppProviderProps>;
-    const useApps: () => AppContextType;
-    const useDrawer: () => DrawerContextType;
-    const useTabs: () => TabsContextType;
-    const useSecondary: () => SecondaryContextType;
-    const Dialog: import("react").FC<StyledDialogProps>;
-    const Select: import("react").FC<StyledSelectProps<string>>;
+    const Provider: import("react").FC<import("./context/AppContext").AppProviderProps>;
+    const useApps: () => import("./BurgerApi").BurgerApi.AppContextType;
+    const useDrawer: () => import("./BurgerApi").BurgerApi.DrawerContextType;
+    const useTabs: () => import("./BurgerApi").BurgerApi.TabsContextType;
+    const useSecondary: () => import("./BurgerApi").BurgerApi.SecondaryContextType;
+    const Dialog: import("react").FC<import("./styles/StyledDialog").StyledDialogProps>;
+    const Select: import("react").FC<import("./styles/StyledSelect").StyledSelectProps<string>>;
     const SelectMultiple: import("react").FC<{
         multiline?: boolean;
         open?: boolean;
@@ -397,13 +716,13 @@ declare namespace Burger {
             sx?: import("@mui/system").SxProps<import("@mui/material").Theme>;
         }[];
         renderValue?: (values: string[]) => React.ReactNode;
-    } & StyledSelectProps<string[]>>;
-    const TextField: import("react").FC<StyledInputFieldProps<string>>;
-    const NumberField: import("react").FC<StyledInputFieldProps<number>>;
-    const FileField: import("react").FC<StyledInputFieldProps<string>>;
-    const DateField: import("react").FC<StyledInputFieldProps<string>>;
-    const DateTimeField: import("react").FC<StyledInputFieldProps<string>>;
-    const TreeItem: import("react").FC<StyledTreeItemProps>;
+    } & import("./styles/StyledSelect").StyledSelectProps<string[]>>;
+    const TextField: import("react").FC<import("./styles/StyledInputField").StyledInputFieldProps<string>>;
+    const NumberField: import("react").FC<import("./styles/StyledInputField").StyledInputFieldProps<number>>;
+    const FileField: import("react").FC<import("./styles/StyledInputField").StyledInputFieldProps<string>>;
+    const DateField: import("react").FC<import("./styles/StyledInputField").StyledInputFieldProps<string>>;
+    const DateTimeField: import("react").FC<import("./styles/StyledInputField").StyledInputFieldProps<string>>;
+    const TreeItem: import("react").FC<import("./styles/StyledTreeItem").StyledTreeItemProps>;
     const TreeItemRoot: import("@emotion/styled").StyledComponent<import("@mui/lab/TreeItem").TreeItemProps & import("react").RefAttributes<HTMLLIElement> & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, {}, {}>;
     const TreeItemOption: import("react").FC<{
         labelText: React.ReactNode;
@@ -412,8 +731,8 @@ declare namespace Burger {
         icon?: React.ElementType<import("@mui/material").SvgIconProps>;
         onClick: () => void;
     }>;
-    const SearchField: import("react").FC<StyledInputFieldProps<string>>;
-    const TransferList: import("react").FC<StyledTransferListProps>;
+    const SearchField: import("react").FC<import("./styles/StyledInputField").StyledInputFieldProps<string>>;
+    const TransferList: import("react").FC<import("./styles/StyledTransferList").StyledTransferListProps>;
     const PrimaryButton: import("react").FC<{
         label: string;
         onClick: (event: React.MouseEvent<HTMLElement>) => void;
@@ -431,10 +750,10 @@ declare namespace Burger {
         onChange?: (newValue: boolean) => void;
         sx?: import("@mui/system").SxProps<import("@mui/material").Theme>;
     }>;
-    const Switch: import("react").FC<StyledSwitchProps>;
+    const Switch: import("react").FC<import("./styles/StyledSwitch").StyledSwitchProps>;
     const RadioButton: import("@emotion/styled").StyledComponent<import("@mui/material").RadioProps & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, {}, {}>;
-    const DateTimeFormatter: import("react").FC<DateTimeFormatProps>;
-    const ReleaseTable: import("react").FC<ReleaseTableProps>;
+    const DateTimeFormatter: import("react").FC<import("./utils/DateTimeFormatter").DateTimeFormatProps>;
+    const ReleaseTable: import("react").FC<import("./releases/ReleaseTable").ReleaseTableProps>;
 }
 
 
@@ -490,27 +809,31 @@ declare module '@mui/material/styles' {
 }
 
 
+declare namespace HdesClient {
+}
+
+
 declare namespace HdesClient {
     const StoreErrorImpl: typeof StoreErrorImplAs;
     const StoreImpl: typeof DefaultStore;
-    class ServiceImpl implements HdesClient.Service {
+    class ServiceImpl implements HdesApi.Service {
         private _store;
         private _branch;
         private _headers;
-        constructor(store: HdesClient.Store, branchName?: string);
-        withBranch(branchName?: string): HdesClient.ServiceImpl;
+        constructor(store: HdesApi.Store, branchName?: string);
+        withBranch(branchName?: string): ServiceImpl;
         get branch(): string | undefined;
-        create(): HdesClient.CreateBuilder;
-        delete(): HdesClient.DeleteBuilder;
-        update(id: string, body: HdesClient.AstCommand[]): Promise<HdesClient.Site>;
-        createAsset(name: string, desc: string | undefined, type: HdesClient.AstBodyType | "SITE", body?: HdesClient.AstCommand[]): Promise<HdesClient.Site>;
-        ast(id: string, body: HdesClient.AstCommand[]): Promise<HdesClient.Entity<any>>;
-        getSite(): Promise<HdesClient.Site>;
-        debug(debug: HdesClient.DebugRequest): Promise<HdesClient.DebugResponse>;
-        copy(id: string, name: string): Promise<HdesClient.Site>;
-        version(): Promise<HdesClient.VersionEntity>;
-        diff(input: HdesClient.DiffRequest): Promise<HdesClient.DiffResponse>;
-        summary(tagId: string): Promise<HdesClient.AstTagSummary>;
+        create(): HdesApi.CreateBuilder;
+        delete(): HdesApi.DeleteBuilder;
+        update(id: string, body: HdesApi.AstCommand[]): Promise<HdesApi.Site>;
+        createAsset(name: string, desc: string | undefined, type: HdesApi.AstBodyType | "SITE", body?: HdesApi.AstCommand[]): Promise<HdesApi.Site>;
+        ast(id: string, body: HdesApi.AstCommand[]): Promise<HdesApi.Entity<any>>;
+        getSite(): Promise<HdesApi.Site>;
+        debug(debug: HdesApi.DebugRequest): Promise<HdesApi.DebugResponse>;
+        copy(id: string, name: string): Promise<HdesApi.Site>;
+        version(): Promise<HdesApi.VersionEntity>;
+        diff(input: HdesApi.DiffRequest): Promise<HdesApi.DiffResponse>;
+        summary(tagId: string): Promise<HdesApi.AstTagSummary>;
     }
 }
 
@@ -546,7 +869,7 @@ declare namespace Composer {
         nav?: Nav;
         withNav(nav: Nav): TabData;
     }
-    interface Tab extends Burger.TabSession<TabData> {
+    interface Tab extends BurgerApi.TabSession<TabData> {
     }
     interface PageUpdate {
         saved: boolean;
@@ -953,55 +1276,55 @@ declare namespace Composer {
         nav?: Nav;
         withNav(nav: Nav): TabData;
     }
-    interface Tab extends Burger.TabSession<TabData> {
+    interface Tab extends BurgerApi.TabSession<TabData> {
     }
     interface DebugSession {
-        error?: HdesClient.StoreError;
-        debug?: HdesClient.DebugResponse;
+        error?: HdesApi.StoreError;
+        debug?: HdesApi.DebugResponse;
         csv?: string;
         json?: string;
-        selected: HdesClient.EntityId;
+        selected: HdesApi.EntityId;
         inputType: DebugInputType;
     }
     type DebugInputType = "CSV" | "JSON";
     interface DebugSessions {
-        selected?: HdesClient.EntityId;
-        values: Record<HdesClient.EntityId, DebugSession>;
+        selected?: HdesApi.EntityId;
+        values: Record<HdesApi.EntityId, DebugSession>;
     }
     interface PageUpdate {
         saved: boolean;
-        origin: HdesClient.Entity<any>;
-        value: HdesClient.AstCommand[];
-        withValue(value: HdesClient.AstCommand[]): PageUpdate;
+        origin: HdesApi.Entity<any>;
+        value: HdesApi.AstCommand[];
+        withValue(value: HdesApi.AstCommand[]): PageUpdate;
     }
     interface Session {
-        site: HdesClient.Site;
-        pages: Record<HdesClient.EntityId, PageUpdate>;
+        site: HdesApi.Site;
+        pages: Record<HdesApi.EntityId, PageUpdate>;
         debug: DebugSessions;
         branchName?: string;
-        getDecision(decisionName: string): undefined | HdesClient.Entity<HdesClient.AstDecision>;
-        getFlow(flowName: string): undefined | HdesClient.Entity<HdesClient.AstFlow>;
-        getService(serviceName: string): undefined | HdesClient.Entity<HdesClient.AstService>;
-        getEntity(id: HdesClient.EntityId): undefined | HdesClient.Entity<any>;
+        getDecision(decisionName: string): undefined | HdesApi.Entity<HdesApi.AstDecision>;
+        getFlow(flowName: string): undefined | HdesApi.Entity<HdesApi.AstFlow>;
+        getService(serviceName: string): undefined | HdesApi.Entity<HdesApi.AstService>;
+        getEntity(id: HdesApi.EntityId): undefined | HdesApi.Entity<any>;
         withDebug(page: DebugSession): Session;
-        withPage(page: HdesClient.EntityId): Session;
-        withPageValue(page: HdesClient.EntityId, value: HdesClient.AstCommand[]): Session;
-        withoutPages(pages: HdesClient.EntityId[]): Session;
+        withPage(page: HdesApi.EntityId): Session;
+        withPageValue(page: HdesApi.EntityId, value: HdesApi.AstCommand[]): Session;
+        withoutPages(pages: HdesApi.EntityId[]): Session;
         withBranch(branchName?: string): Session;
-        withSite(site: HdesClient.Site): Session;
+        withSite(site: HdesApi.Site): Session;
     }
     interface Actions {
         handleLoad(): Promise<void>;
-        handleLoadSite(site?: HdesClient.Site): Promise<void>;
+        handleLoadSite(site?: HdesApi.Site): Promise<void>;
         handleDebugUpdate(debug: DebugSession): void;
-        handlePageUpdate(page: HdesClient.EntityId, value: HdesClient.AstCommand[]): void;
-        handlePageUpdateRemove(pages: HdesClient.EntityId[]): void;
+        handlePageUpdate(page: HdesApi.EntityId, value: HdesApi.AstCommand[]): void;
+        handlePageUpdateRemove(pages: HdesApi.EntityId[]): void;
         handleBranchUpdate(branchName?: string): void;
     }
     interface ContextType {
         session: Session;
         actions: Actions;
-        service: HdesClient.Service;
+        service: HdesApi.Service;
     }
 }
 
@@ -1009,61 +1332,61 @@ declare namespace Composer {
 declare namespace Composer {
     const createTab: (props: {
         nav: Composer.Nav;
-        page?: HdesClient.Entity<any>;
+        page?: HdesApi.Entity<any>;
     }) => ImmutableTabData;
     const ComposerContext: React.Context<ContextType>;
-    const useUnsaved: (entity: HdesClient.Entity<any>) => boolean;
+    const useUnsaved: (entity: HdesApi.Entity<any>) => boolean;
     const useComposer: () => {
         session: Session;
-        service: HdesClient.Service;
+        service: HdesApi.Service;
         actions: Actions;
-        site: HdesClient.Site;
-        isArticleSaved: (entity: HdesClient.Entity<any>) => boolean;
+        site: HdesApi.Site;
+        isArticleSaved: (entity: HdesApi.Entity<any>) => boolean;
     };
-    const useSite: () => HdesClient.Site;
+    const useSite: () => HdesApi.Site;
     const useBranchName: () => string | undefined;
     const useSession: () => Session;
     const useNav: () => {
         handleInTab: (props: {
-            article: HdesClient.Entity<any>;
+            article: HdesApi.Entity<any>;
         }) => void;
-        findTab: (article: HdesClient.Entity<any>) => Composer.Tab | undefined;
+        findTab: (article: HdesApi.Entity<any>) => Composer.Tab | undefined;
     };
     const useDebug: () => {
-        handleDebugInit: (selected: HdesClient.EntityId) => void;
+        handleDebugInit: (selected: HdesApi.EntityId) => void;
     };
     const Provider: React.FC<{
         children: React.ReactNode;
-        service: HdesClient.Service;
+        service: HdesApi.Service;
     }>;
 }
 
 declare namespace Decision {
     const Table: import("react").FC<{
-        ast: import("../../client/api").AstDecision;
+        ast: import("../../client").HdesApi.AstDecision;
         renderHeader: (props: import("./DecisionTable").RenderHeaderProps) => React.ReactNode;
         renderRow: (props: import("./DecisionTable").RenderRowProps) => React.ReactNode;
         renderCell: (props: import("./DecisionTable").RenderCellProps) => React.ReactNode;
     }>;
     const Cell: import("react").FC<{
-        row: import("../../client/api").AstDecisionRow;
-        header: import("../../client/api").TypeDef;
-        cell: import("../../client/api").AstDecisionCell;
+        row: import("../../client").HdesApi.AstDecisionRow;
+        header: import("../../client").HdesApi.TypeDef;
+        cell: import("../../client").HdesApi.AstDecisionCell;
         onClick: () => void;
     }>;
     const Header: import("react").FC<{
-        ast: import("../../client/api").AstDecision;
-        headers: import("../../client/api").TypeDef[];
+        ast: import("../../client").HdesApi.AstDecision;
+        headers: import("../../client").HdesApi.TypeDef[];
         children: React.ReactNode;
-        onClick: (header: import("../../client/api").TypeDef) => void;
+        onClick: (header: import("../../client").HdesApi.TypeDef) => void;
     }>;
     const Row: import("react").FC<{
-        row: import("../../client/api").AstDecisionRow;
-        headers: import("../../client/api").TypeDef[];
+        row: import("../../client").HdesApi.AstDecisionRow;
+        headers: import("../../client").HdesApi.TypeDef[];
         renderCell: (props: {
-            row: import("../../client/api").AstDecisionRow;
-            header: import("../../client/api").TypeDef;
-            cell: import("../../client/api").AstDecisionCell;
+            row: import("../../client").HdesApi.AstDecisionRow;
+            header: import("../../client").HdesApi.TypeDef;
+            cell: import("../../client").HdesApi.AstDecisionCell;
         }) => React.ReactNode;
     }>;
 }