@dxs-ts/eveli-ide 0.0.113 → 0.0.115

package/build/src/wrench/code-editor/ViewImpl.d.ts

@@ -0,0 +1,43 @@
+import { default as CodeMirror } from 'codemirror';
+interface ViewEvents {
+    onChanges?: (content: string) => void;
+    lint?: () => LintMessage[];
+    hint?: (props: HintProps) => CodeMirror.Hints;
+}
+type ViewLang = "yaml" | "groovy" | "json";
+interface ViewProps {
+    id: string;
+    mode: ViewLang;
+    src: string;
+    onChange?: (newValue: string) => void;
+    lint?: () => LintMessage[];
+    hint?: (props: HintProps) => CodeMirror.Hints;
+}
+interface HintProps {
+    pos: CodeMirror.Position;
+    content: string;
+    emptyLine: boolean;
+    cm: CodeMirror.Editor;
+}
+interface LintMessage {
+    line: number;
+    value: string;
+    type: "ERROR" | "WARNING";
+    range?: LintRange;
+}
+interface LintRange {
+    start: number;
+    end: number;
+    column?: number;
+    insert?: boolean;
+}
+interface View {
+    id: string;
+    withValue(value: string): View;
+    withEvents(events: ViewEvents): View;
+    remove(): void;
+    refresh(): void;
+}
+declare const createView: (area: React.RefObject<HTMLTextAreaElement>, props: ViewProps) => View;
+export { createView };
+export type { View, ViewProps, HintProps };

package/build/src/wrench/code-editor/index.d.ts

@@ -0,0 +1,4 @@
+import { CodeEditor } from './CodeEditor';
+import { HintProps } from './ViewImpl';
+export type { HintProps };
+export default CodeEditor;

package/build/src/wrench/core/Activities.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+export interface ActivityProps {
+    title: React.ReactNode;
+    desc: React.ReactNode;
+    buttonCreate: React.ReactNode;
+    buttonViewAll?: React.ReactNode;
+    onView?: () => void;
+    composer: React.FC<{
+        onClose: () => void;
+    }>;
+}
+export declare function useActivities(): ActivityProps[];
+export declare const Activities: React.FC<{}>;

package/build/src/wrench/core/Main.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const Main: React.FC<{}>;
+export { Main };

package/build/src/wrench/core/Secondary.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const Secondary: React.FC<{}>;

package/build/src/wrench/core/Tabs.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const Tabs: React.FC<{}>;

package/build/src/wrench/core/Toolbar.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const Toolbar: React.FC<{}>;
+export default Toolbar;

package/build/src/wrench/core/client/api.d.ts

@@ -0,0 +1,339 @@
+export 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 {
+        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 StoreError extends Error {
+        text: string;
+        status: number;
+        errors: ServiceErrorMsg[];
+    }
+    interface StoreConfig {
+        url: string;
+        oidc?: string;
+        status?: string;
+        csrf?: {
+            key: string;
+            value: string;
+        };
+    }
+}

package/build/src/wrench/core/client/error.d.ts

@@ -0,0 +1,2 @@
+import { HdesApi } from './api';
+export declare const parseErrors: (props: any[]) => HdesApi.ServiceErrorMsg[];

package/build/src/wrench/core/client/index.d.ts

@@ -0,0 +1,35 @@
+import { HdesApi } from './api';
+declare namespace HdesClient {
+}
+declare namespace HdesClient {
+    interface ServiceRestApi {
+        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>;
+        remove(id: string): Promise<HdesApi.Site>;
+        importTag(tagContentAsString: string): Promise<HdesApi.Site>;
+    }
+    class ServiceImpl implements HdesApi.Service {
+        private _api;
+        constructor(props: ServiceRestApi);
+        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 type { HdesApi };
+export default HdesClient;

package/build/src/wrench/core/compare/CompareView.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { HdesApi } from '../client';
+declare const AssetMapper: React.FC<{
+    assets?: HdesApi.AstTagSummary;
+}>;
+declare const CompareView: React.FC;
+export { CompareView, AssetMapper };

package/build/src/wrench/core/compare/index.d.ts

@@ -0,0 +1,2 @@
+import { CompareView } from './CompareView';
+export { CompareView };

package/build/src/wrench/core/context/Reducer.d.ts

@@ -0,0 +1,38 @@
+import { default as Ide } from './ide';
+import { HdesApi } from '../client';
+declare enum ActionType {
+    setDebugUpdate = "setDebugUpdate",
+    setSite = "setSite",
+    setPageUpdate = "setPageUpdate",
+    setPageUpdateRemove = "setPageUpdateRemove",
+    setBranchUpdate = "setBranchUpdate"
+}
+interface Action {
+    type: ActionType;
+    setPageUpdateRemove?: {
+        pages: HdesApi.EntityId[];
+    };
+    setPageUpdate?: {
+        page: HdesApi.EntityId;
+        value: HdesApi.AstCommand[];
+    };
+    setSite?: {
+        site: HdesApi.Site;
+    };
+    setDebugUpdate?: Ide.DebugSession;
+    setBranchUpdate?: string;
+}
+declare class ReducerDispatch implements Ide.Actions {
+    private _sessionDispatch;
+    private _service;
+    constructor(session: React.Dispatch<Action>, service: HdesApi.Service);
+    handleLoad(): Promise<void>;
+    handleLoadSite(site?: HdesApi.Site): Promise<void>;
+    handleBranchUpdate(branchName?: string): void;
+    handleDebugUpdate(debug: Ide.DebugSession): void;
+    handlePageUpdate(page: HdesApi.EntityId, value: HdesApi.AstCommand[]): void;
+    handlePageUpdateRemove(pages: HdesApi.EntityId[]): void;
+}
+declare const Reducer: (state: Ide.Session, action: Action) => Ide.Session;
+export type { Action };
+export { Reducer, ReducerDispatch, ActionType };

package/build/src/wrench/core/context/SessionData.d.ts

@@ -0,0 +1,45 @@
+import { default as WrenchComposerApi } from './ide';
+import { HdesApi } from '../client';
+declare class SiteCache {
+    private _site;
+    private _decisions;
+    private _flows;
+    private _services;
+    constructor(site: HdesApi.Site);
+    private visitFlow;
+    private visitDecision;
+    private visitService;
+    getEntity(entityId: HdesApi.EntityId): HdesApi.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>;
+}
+declare class SessionData implements WrenchComposerApi.Session {
+    private _site;
+    private _pages;
+    private _cache;
+    private _debug;
+    private _branchName?;
+    constructor(props: {
+        site?: HdesApi.Site;
+        pages?: Record<HdesApi.EntityId, WrenchComposerApi.PageUpdate>;
+        cache?: SiteCache;
+        debug?: WrenchComposerApi.DebugSessions;
+        branchName?: string;
+    });
+    get site(): HdesApi.Site;
+    get pages(): Record<string, WrenchComposerApi.PageUpdate>;
+    get debug(): WrenchComposerApi.DebugSessions;
+    get branchName(): string | undefined;
+    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(entityId: HdesApi.EntityId): HdesApi.Entity<any> | undefined;
+    withSite(site: HdesApi.Site): SessionData;
+    withDebug(debugSession: WrenchComposerApi.DebugSession): SessionData;
+    withBranch(branchName: string): WrenchComposerApi.Session;
+    withoutPages(pageIds: HdesApi.EntityId[]): WrenchComposerApi.Session;
+    withPage(page: HdesApi.EntityId): WrenchComposerApi.Session;
+    withPageValue(page: HdesApi.EntityId, value: HdesApi.AstCommand[]): WrenchComposerApi.Session;
+}
+export { SessionData };

package/build/src/wrench/core/context/ide.d.ts

@@ -0,0 +1,75 @@
+import { default as React } from 'react';
+import { HdesApi } from '../client';
+declare namespace WrenchComposerApi {
+    interface DebugSession {
+        error?: HdesApi.StoreError;
+        debug?: HdesApi.DebugResponse;
+        csv?: string;
+        json?: string;
+        selected: HdesApi.EntityId;
+        inputType: DebugInputType;
+    }
+    type DebugInputType = "CSV" | "JSON";
+    interface DebugSessions {
+        selected?: HdesApi.EntityId;
+        values: Record<HdesApi.EntityId, DebugSession>;
+    }
+    interface PageUpdate {
+        saved: boolean;
+        origin: HdesApi.Entity<any>;
+        value: HdesApi.AstCommand[];
+        withValue(value: HdesApi.AstCommand[]): PageUpdate;
+    }
+    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 WrenchComposerApi {
+    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 useQueryHeaders: () => Record<string, string>;
+    const useSession: () => Session;
+    const useDebug: () => {
+        handleDebugInit: (selected: HdesApi.EntityId) => void;
+    };
+    const Provider: React.FC<{
+        children: React.ReactNode;
+        service: HdesApi.Service;
+    }>;
+}
+export default WrenchComposerApi;

package/build/src/wrench/core/context/index.d.ts

@@ -0,0 +1,2 @@
+import { default as Composer } from './ide';
+export { Composer };

package/build/src/wrench/core/debug/DebugError.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { HdesApi } from '../client';
+declare const DebugError: React.FC<{
+    error: HdesApi.StoreError;
+}>;
+export { DebugError };

package/build/src/wrench/core/debug/DebugHeader.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+declare const DebugHeader: React.FC<{
+    children: React.ReactNode;
+}>;
+export type {};
+export { DebugHeader };

package/build/src/wrench/core/debug/DebugInput.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { Composer } from '../context';
+declare const DebugInput: React.FC<{
+    type: Composer.DebugInputType;
+    csv: string;
+    json: string;
+}>;
+export type {};
+export { DebugInput };

package/build/src/wrench/core/debug/DebugView.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const DebugView: React.FC<{}>;
+export { DebugView };

package/build/src/wrench/core/debug/api.d.ts

@@ -0,0 +1 @@
+export type DebugOptionType = "SELECT_ASSET" | "INPUT_CSV" | "INPUT_FORM" | "INPUT_JSON" | "DRAWER";

package/build/src/wrench/core/debug/drawer/DebugDrawer.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { DebugOptionType } from '../api';
+declare const DebugDrawer: React.FC<{
+    open: boolean;
+    selected?: string;
+    onClose: () => void;
+    onSelect: (type: DebugOptionType) => void;
+}>;
+export { DebugDrawer };