@dxs-ts/eveli-ide 0.0.8 → 0.0.13

package/build/index.d.ts

@@ -1,27 +1,349 @@
 import { default as default_2 } from 'react';
 import { Theme } from '@mui/material/styles';
 
-declare class DefaultStore implements Store {
-    private _config;
-    private _updateStarted;
-    private _iapSessionRefreshWindow;
-    private _defRef;
-    constructor(config: 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 +638,53 @@ 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);
-    get name(): string;
-    get status(): number;
-    get errors(): 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 StoreErrorImpl extends Error {
+        private _props;
+        constructor(props: HdesApi.ServiceErrorProps);
+        get name(): string;
+        get status(): number;
+        get errors(): HdesApi.ServiceErrorMsg[];
+    }
+    export class DefaultStore implements HdesApi.Store {
+        private _config;
+        private _updateStarted;
+        private _iapSessionRefreshWindow;
+        private _defRef;
+        constructor(config: HdesApi.StoreConfig);
+        iapRefresh(): Promise<void>;
+        iapLogin(): boolean;
+        handle401(): Promise<void>;
+        fetch<T>(path: string, req?: RequestInit): Promise<T>;
+    }
+    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;
 }
 
@@ -380,64 +695,6 @@ export declare const wrenchIntl: {
 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 SelectMultiple: import("react").FC<{
-        multiline?: boolean;
-        open?: boolean;
-        helpers?: {
-            id: string;
-            value: string | React.ReactChild;
-            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>;
-    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;
-        nodeId: string;
-        color: string;
-        icon?: React.ElementType<import("@mui/material").SvgIconProps>;
-        onClick: () => void;
-    }>;
-    const SearchField: import("react").FC<StyledInputFieldProps<string>>;
-    const TransferList: import("react").FC<StyledTransferListProps>;
-    const PrimaryButton: import("react").FC<{
-        label: string;
-        onClick: (event: React.MouseEvent<HTMLElement>) => void;
-        sx?: import("@mui/system").SxProps<import("@mui/material").Theme>;
-        disabled?: boolean;
-    }>;
-    const SecondaryButton: import("react").FC<{
-        label?: string;
-        onClick: (event: React.MouseEvent<HTMLElement>) => void;
-        sx?: import("@mui/system").SxProps<import("@mui/material").Theme>;
-        disabled?: boolean;
-    }>;
-    const Checkbox: import("react").FC<{
-        checked: boolean;
-        onChange?: (newValue: boolean) => void;
-        sx?: import("@mui/system").SxProps<import("@mui/material").Theme>;
-    }>;
-    const Switch: import("react").FC<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>;
-}
-
-
 declare module 'react' {
     interface CSSProperties {
         '--tree-view-text-color'?: string;
@@ -491,101 +748,365 @@ declare module '@mui/material/styles' {
 
 
 declare namespace HdesClient {
-    const StoreErrorImpl: typeof StoreErrorImplAs;
-    const StoreImpl: typeof DefaultStore;
-    class ServiceImpl implements HdesClient.Service {
+}
+
+
+declare namespace HdesClient {
+    class StoreErrorImpl extends Error {
+        private _props;
+        constructor(props: HdesApi.ServiceErrorProps);
+        get name(): string;
+        get status(): number;
+        get errors(): HdesApi.ServiceErrorMsg[];
+    }
+    class DefaultStore implements HdesApi.Store {
+        private _config;
+        private _updateStarted;
+        private _iapSessionRefreshWindow;
+        private _defRef;
+        constructor(config: HdesApi.StoreConfig);
+        iapRefresh(): Promise<void>;
+        iapLogin(): boolean;
+        handle401(): Promise<void>;
+        fetch<T>(path: string, req?: RequestInit): Promise<T>;
+    }
+    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>;
     }
 }
 
-declare namespace StencilClient {
-    type PageId = string;
-    type LinkId = string;
-    type ArticleId = string;
-    type WorkflowId = string;
-    type LocaleId = string;
-    type Locale = string;
-    type LocalisedMarkdown = string;
-    type LocalisedContent = string;
-    type ReleaseId = string;
-    type TemplateId = string;
-    type LinkType = "internal" | "external" | "phone";
-    type TemplateType = "page";
-    interface Site {
-        name: string;
-        contentType: "OK" | "NOT_CREATED" | "EMPTY" | "ERRORS" | "NO_CONNECTION";
-        locales: Record<string, SiteLocale>;
-        pages: Record<PageId, Page>;
-        links: Record<LinkId, Link>;
-        articles: Record<ArticleId, Article>;
-        workflows: Record<WorkflowId, Workflow>;
-        releases: Record<ReleaseId, Release>;
-        templates: Record<TemplateId, Template>;
-    }
-    interface SiteLocale {
-        id: LocaleId;
-        body: {
-            value: Locale;
-            enabled: boolean;
-        };
+
+declare namespace Composer {
+    interface Nav {
+        value?: string | null;
     }
-    interface LocaleMutator {
-        localeId: LocaleId;
-        value: string;
-        enabled: boolean;
+    interface TabData {
+        nav?: Nav;
+        withNav(nav: Nav): TabData;
     }
-    interface Page {
-        id: PageId;
-        created: string;
-        modified: string;
-        body: {
-            article: ArticleId;
-            locale: Locale;
-            content: LocalisedMarkdown;
-            devMode?: boolean;
-        };
+    interface Tab extends BurgerApi.TabSession<TabData> {
     }
-    interface PageMutator {
-        pageId: PageId;
-        locale: Locale;
-        content: LocalisedContent;
-        devMode: boolean | undefined;
+    interface DebugSession {
+        error?: HdesApi.StoreError;
+        debug?: HdesApi.DebugResponse;
+        csv?: string;
+        json?: string;
+        selected: HdesApi.EntityId;
+        inputType: DebugInputType;
     }
-    interface Template {
-        id: TemplateId;
-        body: {
-            type: TemplateType;
-            name: string;
-            description: string;
-            content: string;
-        };
+    type DebugInputType = "CSV" | "JSON";
+    interface DebugSessions {
+        selected?: HdesApi.EntityId;
+        values: Record<HdesApi.EntityId, DebugSession>;
     }
-    interface TemplateMutator {
-        id: TemplateId;
-        type: TemplateType;
-        name: string;
-        description: string;
-        content: string;
+    interface PageUpdate {
+        saved: boolean;
+        origin: HdesApi.Entity<any>;
+        value: HdesApi.AstCommand[];
+        withValue(value: HdesApi.AstCommand[]): PageUpdate;
     }
-    interface Article {
-        id: ArticleId;
-        body: {
+    interface Session {
+        site: HdesApi.Site;
+        pages: Record<HdesApi.EntityId, PageUpdate>;
+        debug: DebugSessions;
+        branchName?: string;
+        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: HdesApi.EntityId): Session;
+        withPageValue(page: HdesApi.EntityId, value: HdesApi.AstCommand[]): Session;
+        withoutPages(pages: HdesApi.EntityId[]): Session;
+        withBranch(branchName?: string): Session;
+        withSite(site: HdesApi.Site): Session;
+    }
+    interface Actions {
+        handleLoad(): Promise<void>;
+        handleLoadSite(site?: HdesApi.Site): Promise<void>;
+        handleDebugUpdate(debug: DebugSession): 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: HdesApi.Service;
+    }
+}
+
+
+declare namespace Composer {
+    const createTab: (props: {
+        nav: Composer.Nav;
+        page?: HdesApi.Entity<any>;
+    }) => ImmutableTabData;
+    const ComposerContext: React.Context<ContextType>;
+    const useUnsaved: (entity: HdesApi.Entity<any>) => boolean;
+    const useComposer: () => {
+        session: Session;
+        service: HdesApi.Service;
+        actions: Actions;
+        site: HdesApi.Site;
+        isArticleSaved: (entity: HdesApi.Entity<any>) => boolean;
+    };
+    const useSite: () => HdesApi.Site;
+    const useBranchName: () => string | undefined;
+    const useSession: () => Session;
+    const useNav: () => {
+        handleInTab: (props: {
+            article: HdesApi.Entity<any>;
+        }) => void;
+        findTab: (article: HdesApi.Entity<any>) => Composer.Tab | undefined;
+    };
+    const useDebug: () => {
+        handleDebugInit: (selected: HdesApi.EntityId) => void;
+    };
+    const Provider: React.FC<{
+        children: React.ReactNode;
+        service: HdesApi.Service;
+    }>;
+}
+
+
+declare namespace Composer {
+    interface SearchData {
+        values: readonly SearchDataEntry[];
+        filterLinks(keyword: string): readonly SearchResult[];
+        filterWorkflows(keyword: string): readonly SearchResult[];
+        filterArticles(keyword: string): readonly SearchResult[];
+    }
+    interface SearchDataEntry {
+        id: string;
+        type: "ARTICLE" | "LINK" | "WORKFLOW";
+        values: readonly SearchableValue[];
+    }
+    interface SearchResult {
+        source: SearchDataEntry;
+        matches: SearchableValue[];
+    }
+    interface SearchableValue {
+        id: string;
+        value: string;
+        type: "ARTICLE_NAME" | "ARTICLE_PAGE" | "WORKFLOW_NAME" | "WORKFLOW_LABEL" | "LINK_VALUE" | "LINK_LABEL";
+    }
+    type NavType = "ARTICLE_LINKS" | "ARTICLE_WORKFLOWS" | "ARTICLE_PAGES";
+    interface Nav {
+        type: NavType;
+        value?: string | null;
+        value2?: string | null;
+    }
+    interface TabData {
+        nav?: Nav;
+        withNav(nav: Nav): TabData;
+    }
+    interface Tab extends BurgerApi.TabSession<TabData> {
+    }
+    interface PageUpdate {
+        saved: boolean;
+        origin: StencilClient.Page;
+        value: StencilClient.LocalisedContent;
+        withValue(value: StencilClient.LocalisedContent): PageUpdate;
+    }
+    interface SessionFilter {
+        locale?: StencilClient.LocaleId;
+        withLocale(locale?: StencilClient.LocaleId): SessionFilter;
+    }
+    interface Session {
+        site: StencilClient.Site;
+        pages: Record<StencilClient.PageId, PageUpdate>;
+        articles: ArticleView[];
+        workflows: WorkflowView[];
+        links: LinkView[];
+        search: SearchData;
+        filter: SessionFilter;
+        getArticleName(articleId: StencilClient.ArticleId): {
+            missing: boolean;
+            name: string;
+        };
+        getArticleView(articleId: StencilClient.ArticleId): ArticleView;
+        getLinkView(linkId: StencilClient.LinkId): LinkView;
+        getLinkName(linkId: StencilClient.LinkId): {
+            missing: boolean;
+            name: string;
+        };
+        getWorkflowView(workflowId: StencilClient.WorkflowId): WorkflowView;
+        getWorkflowName(workflowId: StencilClient.WorkflowId): {
+            missing: boolean;
+            name: string;
+        };
+        getArticlesForLocale(locale: StencilClient.LocaleId): StencilClient.Article[];
+        getArticlesForLocales(locales: StencilClient.LocaleId[]): StencilClient.Article[];
+        withPage(page: StencilClient.PageId): Session;
+        withPageValue(page: StencilClient.PageId, value: StencilClient.LocalisedContent): Session;
+        withoutPages(pages: StencilClient.PageId[]): Session;
+        withLocaleFilter(locale?: StencilClient.LocaleId): Session;
+        withSite(site: StencilClient.Site): Session;
+    }
+    interface Actions {
+        handleLoad(): Promise<void>;
+        handleLoadSite(): Promise<void>;
+        handlePageUpdate(page: StencilClient.PageId, value: StencilClient.LocalisedContent): void;
+        handlePageUpdateRemove(pages: StencilClient.PageId[]): void;
+        handleLocaleFilter(locale?: StencilClient.LocaleId): void;
+    }
+    interface ContextType {
+        session: Session;
+        actions: Actions;
+        service: StencilClient.Service;
+    }
+    interface ArticleView {
+        article: StencilClient.Article;
+        pages: PageView[];
+        canCreate: StencilClient.SiteLocale[];
+        links: LinkView[];
+        workflows: WorkflowView[];
+        children: Composer.ArticleView[];
+        displayOrder: number;
+        getPageById(pageId: StencilClient.PageId): PageView;
+        getPageByLocaleId(localeId: StencilClient.LocaleId): PageView;
+        findPageByLocaleId(localeId: StencilClient.LocaleId): PageView | undefined;
+    }
+    interface PageView {
+        title: string;
+        page: StencilClient.Page;
+        locale: StencilClient.SiteLocale;
+    }
+    interface LinkView {
+        link: StencilClient.Link;
+        labels: LabelView[];
+    }
+    interface WorkflowView {
+        workflow: StencilClient.Workflow;
+        labels: LabelView[];
+    }
+    interface LabelView {
+        label: StencilClient.LocaleLabel;
+        locale: StencilClient.SiteLocale;
+    }
+}
+
+
+declare namespace Composer {
+    const createTab: (props: {
+        nav: Composer.Nav;
+        page?: StencilClient.Page;
+    }) => ImmutableTabData;
+    const ComposerContext: React.Context<ContextType>;
+    const useUnsaved: (article: StencilClient.Article) => boolean;
+    const useComposer: () => {
+        session: Session;
+        service: StencilClient.Service;
+        actions: Actions;
+        site: StencilClient.Site;
+        isArticleSaved: (article: StencilClient.Article) => boolean;
+    };
+    const useSite: () => StencilClient.Site;
+    const useSession: () => Session;
+    const useNav: () => {
+        handleInTab: (props: {
+            article: StencilClient.Article;
+            type: Composer.NavType;
+            locale?: string | null;
+            secondary?: boolean;
+        }) => void;
+        findTab: (article: StencilClient.Article) => Composer.Tab | undefined;
+    };
+    const Provider: React.FC<{
+        children: React.ReactNode;
+        service: StencilClient.Service;
+    }>;
+}
+
+declare namespace StencilClient {
+    type PageId = string;
+    type LinkId = string;
+    type ArticleId = string;
+    type WorkflowId = string;
+    type LocaleId = string;
+    type Locale = string;
+    type LocalisedMarkdown = string;
+    type LocalisedContent = string;
+    type ReleaseId = string;
+    type TemplateId = string;
+    type LinkType = "internal" | "external" | "phone";
+    type TemplateType = "page";
+    interface Site {
+        name: string;
+        contentType: "OK" | "NOT_CREATED" | "EMPTY" | "ERRORS" | "NO_CONNECTION";
+        locales: Record<string, SiteLocale>;
+        pages: Record<PageId, Page>;
+        links: Record<LinkId, Link>;
+        articles: Record<ArticleId, Article>;
+        workflows: Record<WorkflowId, Workflow>;
+        releases: Record<ReleaseId, Release>;
+        templates: Record<TemplateId, Template>;
+    }
+    interface SiteLocale {
+        id: LocaleId;
+        body: {
+            value: Locale;
+            enabled: boolean;
+        };
+    }
+    interface LocaleMutator {
+        localeId: LocaleId;
+        value: string;
+        enabled: boolean;
+    }
+    interface Page {
+        id: PageId;
+        created: string;
+        modified: string;
+        body: {
+            article: ArticleId;
+            locale: Locale;
+            content: LocalisedMarkdown;
+            devMode?: boolean;
+        };
+    }
+    interface PageMutator {
+        pageId: PageId;
+        locale: Locale;
+        content: LocalisedContent;
+        devMode: boolean | undefined;
+    }
+    interface Template {
+        id: TemplateId;
+        body: {
+            type: TemplateType;
+            name: string;
+            description: string;
+            content: string;
+        };
+    }
+    interface TemplateMutator {
+        id: TemplateId;
+        type: TemplateType;
+        name: string;
+        description: string;
+        content: string;
+    }
+    interface Article {
+        id: ArticleId;
+        body: {
             parentId?: ArticleId;
             name: string;
             order: number;
@@ -794,276 +1315,32 @@ declare namespace StencilClient {
     }) => Service;
 }
 
-
-declare namespace Composer {
-    interface SearchData {
-        values: readonly SearchDataEntry[];
-        filterLinks(keyword: string): readonly SearchResult[];
-        filterWorkflows(keyword: string): readonly SearchResult[];
-        filterArticles(keyword: string): readonly SearchResult[];
-    }
-    interface SearchDataEntry {
-        id: string;
-        type: "ARTICLE" | "LINK" | "WORKFLOW";
-        values: readonly SearchableValue[];
-    }
-    interface SearchResult {
-        source: SearchDataEntry;
-        matches: SearchableValue[];
-    }
-    interface SearchableValue {
-        id: string;
-        value: string;
-        type: "ARTICLE_NAME" | "ARTICLE_PAGE" | "WORKFLOW_NAME" | "WORKFLOW_LABEL" | "LINK_VALUE" | "LINK_LABEL";
-    }
-    type NavType = "ARTICLE_LINKS" | "ARTICLE_WORKFLOWS" | "ARTICLE_PAGES";
-    interface Nav {
-        type: NavType;
-        value?: string | null;
-        value2?: string | null;
-    }
-    interface TabData {
-        nav?: Nav;
-        withNav(nav: Nav): TabData;
-    }
-    interface Tab extends Burger.TabSession<TabData> {
-    }
-    interface PageUpdate {
-        saved: boolean;
-        origin: StencilClient.Page;
-        value: StencilClient.LocalisedContent;
-        withValue(value: StencilClient.LocalisedContent): PageUpdate;
-    }
-    interface SessionFilter {
-        locale?: StencilClient.LocaleId;
-        withLocale(locale?: StencilClient.LocaleId): SessionFilter;
-    }
-    interface Session {
-        site: StencilClient.Site;
-        pages: Record<StencilClient.PageId, PageUpdate>;
-        articles: ArticleView[];
-        workflows: WorkflowView[];
-        links: LinkView[];
-        search: SearchData;
-        filter: SessionFilter;
-        getArticleName(articleId: StencilClient.ArticleId): {
-            missing: boolean;
-            name: string;
-        };
-        getArticleView(articleId: StencilClient.ArticleId): ArticleView;
-        getLinkView(linkId: StencilClient.LinkId): LinkView;
-        getLinkName(linkId: StencilClient.LinkId): {
-            missing: boolean;
-            name: string;
-        };
-        getWorkflowView(workflowId: StencilClient.WorkflowId): WorkflowView;
-        getWorkflowName(workflowId: StencilClient.WorkflowId): {
-            missing: boolean;
-            name: string;
-        };
-        getArticlesForLocale(locale: StencilClient.LocaleId): StencilClient.Article[];
-        getArticlesForLocales(locales: StencilClient.LocaleId[]): StencilClient.Article[];
-        withPage(page: StencilClient.PageId): Session;
-        withPageValue(page: StencilClient.PageId, value: StencilClient.LocalisedContent): Session;
-        withoutPages(pages: StencilClient.PageId[]): Session;
-        withLocaleFilter(locale?: StencilClient.LocaleId): Session;
-        withSite(site: StencilClient.Site): Session;
-    }
-    interface Actions {
-        handleLoad(): Promise<void>;
-        handleLoadSite(): Promise<void>;
-        handlePageUpdate(page: StencilClient.PageId, value: StencilClient.LocalisedContent): void;
-        handlePageUpdateRemove(pages: StencilClient.PageId[]): void;
-        handleLocaleFilter(locale?: StencilClient.LocaleId): void;
-    }
-    interface ContextType {
-        session: Session;
-        actions: Actions;
-        service: StencilClient.Service;
-    }
-    interface ArticleView {
-        article: StencilClient.Article;
-        pages: PageView[];
-        canCreate: StencilClient.SiteLocale[];
-        links: LinkView[];
-        workflows: WorkflowView[];
-        children: Composer.ArticleView[];
-        displayOrder: number;
-        getPageById(pageId: StencilClient.PageId): PageView;
-        getPageByLocaleId(localeId: StencilClient.LocaleId): PageView;
-        findPageByLocaleId(localeId: StencilClient.LocaleId): PageView | undefined;
-    }
-    interface PageView {
-        title: string;
-        page: StencilClient.Page;
-        locale: StencilClient.SiteLocale;
-    }
-    interface LinkView {
-        link: StencilClient.Link;
-        labels: LabelView[];
-    }
-    interface WorkflowView {
-        workflow: StencilClient.Workflow;
-        labels: LabelView[];
-    }
-    interface LabelView {
-        label: StencilClient.LocaleLabel;
-        locale: StencilClient.SiteLocale;
-    }
-}
-
-
-declare namespace Composer {
-    const createTab: (props: {
-        nav: Composer.Nav;
-        page?: StencilClient.Page;
-    }) => ImmutableTabData;
-    const ComposerContext: React.Context<ContextType>;
-    const useUnsaved: (article: StencilClient.Article) => boolean;
-    const useComposer: () => {
-        session: Session;
-        service: StencilClient.Service;
-        actions: Actions;
-        site: StencilClient.Site;
-        isArticleSaved: (article: StencilClient.Article) => boolean;
-    };
-    const useSite: () => StencilClient.Site;
-    const useSession: () => Session;
-    const useNav: () => {
-        handleInTab: (props: {
-            article: StencilClient.Article;
-            type: Composer.NavType;
-            locale?: string | null;
-            secondary?: boolean;
-        }) => void;
-        findTab: (article: StencilClient.Article) => Composer.Tab | undefined;
-    };
-    const Provider: React.FC<{
-        children: React.ReactNode;
-        service: StencilClient.Service;
-    }>;
-}
-
-
-declare namespace Composer {
-    interface Nav {
-        value?: string | null;
-    }
-    interface TabData {
-        nav?: Nav;
-        withNav(nav: Nav): TabData;
-    }
-    interface Tab extends Burger.TabSession<TabData> {
-    }
-    interface DebugSession {
-        error?: HdesClient.StoreError;
-        debug?: HdesClient.DebugResponse;
-        csv?: string;
-        json?: string;
-        selected: HdesClient.EntityId;
-        inputType: DebugInputType;
-    }
-    type DebugInputType = "CSV" | "JSON";
-    interface DebugSessions {
-        selected?: HdesClient.EntityId;
-        values: Record<HdesClient.EntityId, DebugSession>;
-    }
-    interface PageUpdate {
-        saved: boolean;
-        origin: HdesClient.Entity<any>;
-        value: HdesClient.AstCommand[];
-        withValue(value: HdesClient.AstCommand[]): PageUpdate;
-    }
-    interface Session {
-        site: HdesClient.Site;
-        pages: Record<HdesClient.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>;
-        withDebug(page: DebugSession): Session;
-        withPage(page: HdesClient.EntityId): Session;
-        withPageValue(page: HdesClient.EntityId, value: HdesClient.AstCommand[]): Session;
-        withoutPages(pages: HdesClient.EntityId[]): Session;
-        withBranch(branchName?: string): Session;
-        withSite(site: HdesClient.Site): Session;
-    }
-    interface Actions {
-        handleLoad(): Promise<void>;
-        handleLoadSite(site?: HdesClient.Site): Promise<void>;
-        handleDebugUpdate(debug: DebugSession): void;
-        handlePageUpdate(page: HdesClient.EntityId, value: HdesClient.AstCommand[]): void;
-        handlePageUpdateRemove(pages: HdesClient.EntityId[]): void;
-        handleBranchUpdate(branchName?: string): void;
-    }
-    interface ContextType {
-        session: Session;
-        actions: Actions;
-        service: HdesClient.Service;
-    }
-}
-
-
-declare namespace Composer {
-    const createTab: (props: {
-        nav: Composer.Nav;
-        page?: HdesClient.Entity<any>;
-    }) => ImmutableTabData;
-    const ComposerContext: React.Context<ContextType>;
-    const useUnsaved: (entity: HdesClient.Entity<any>) => boolean;
-    const useComposer: () => {
-        session: Session;
-        service: HdesClient.Service;
-        actions: Actions;
-        site: HdesClient.Site;
-        isArticleSaved: (entity: HdesClient.Entity<any>) => boolean;
-    };
-    const useSite: () => HdesClient.Site;
-    const useBranchName: () => string | undefined;
-    const useSession: () => Session;
-    const useNav: () => {
-        handleInTab: (props: {
-            article: HdesClient.Entity<any>;
-        }) => void;
-        findTab: (article: HdesClient.Entity<any>) => Composer.Tab | undefined;
-    };
-    const useDebug: () => {
-        handleDebugInit: (selected: HdesClient.EntityId) => void;
-    };
-    const Provider: React.FC<{
-        children: React.ReactNode;
-        service: HdesClient.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;
     }>;
 }