abap-adt-api/build/api/atc.d.ts

Interface to Abap Developer Tools webservice

import { AdtHTTP } from "../AdtHTTP";
import { Clean } from "../utilities";
import * as t from "io-ts";
declare const atcProposal: t.IntersectionC<[t.TypeC<{
    finding: t.UnionC<[t.IntersectionC<[t.TypeC<{
        uri: t.StringC;
        type: t.StringC;
        name: t.StringC;
        location: t.StringC;
        processor: t.StringC;
        lastChangedBy: t.StringC;
        priority: t.NumberC;
        checkId: t.StringC;
        checkTitle: t.StringC;
        messageId: t.StringC;
        messageTitle: t.StringC;
        exemptionApproval: t.StringC;
        exemptionKind: t.UnionC<[t.LiteralC<"A">, t.LiteralC<"I">, t.LiteralC<"">, t.StringC]>;
        checksum: t.NumberC;
        quickfixInfo: t.StringC;
    }>, t.PartialC<{
        quickfixes: t.PartialC<{
            automatic: t.BooleanC;
            manual: t.BooleanC;
            pseudo: t.BooleanC;
        }>;
    }>]>, t.StringC]>;
    package: t.StringC;
    subObject: t.StringC;
    subObjectType: t.StringC;
    subObjectTypeDescr: t.StringC;
    objectTypeDescr: t.StringC;
    approver: t.StringC;
    reason: t.UnionC<[t.LiteralC<"FPOS">, t.LiteralC<"OTHR">, t.LiteralC<"">]>;
    justification: t.StringC;
    notify: t.UnionC<[t.LiteralC<"never">, t.LiteralC<"on_rejection">, t.LiteralC<"always">]>;
    restriction: t.TypeC<{
        enabled: t.BooleanC;
        singlefinding: t.BooleanC;
        rangeOfFindings: t.TypeC<{
            enabled: t.BooleanC;
            restrictByObject: t.TypeC<{
                object: t.BooleanC;
                package: t.BooleanC;
                subobject: t.BooleanC;
                target: t.UnionC<[t.LiteralC<"subobject">, t.LiteralC<"object">, t.LiteralC<"package">, t.LiteralC<"">]>;
            }>;
            restrictByCheck: t.TypeC<{
                check: t.BooleanC;
                message: t.BooleanC;
                target: t.UnionC<[t.LiteralC<"message">, t.LiteralC<"check">, t.LiteralC<"">]>;
            }>;
        }>;
    }>;
}>, t.PartialC<{
    apprIsArea: t.StringC;
    checkClass: t.StringC;
    validUntil: t.StringC;
}>]>;
declare const atcProposalMessage: t.TypeC<{
    type: t.StringC;
    message: t.StringC;
}>;
export interface RestrictByObject {
    object: boolean;
    package: boolean;
    subobject: boolean;
    text: string;
}
declare const atcRunResult: t.TypeC<{
    id: t.StringC;
    timestamp: t.NumberC;
    infos: t.ArrayC<t.TypeC<{
        type: t.StringC;
        description: t.StringC;
    }>>;
}>;
declare const atcCustomizingi: t.TypeC<{
    properties: t.ArrayC<t.TypeC<{
        name: t.StringC;
        value: t.UnionC<[t.BooleanC, t.StringC]>;
    }>>;
    excemptions: t.ArrayC<t.TypeC<{
        id: t.StringC;
        justificationMandatory: t.BooleanC;
        title: t.StringC;
    }>>;
}>;
declare const atcWorklist: t.TypeC<{
    id: t.StringC;
    timestamp: t.NumberC;
    usedObjectSet: t.StringC;
    objectSetIsComplete: t.BooleanC;
    objectSets: t.ArrayC<t.TypeC<{
        name: t.StringC;
        title: t.StringC;
        kind: t.StringC;
    }>>;
    objects: t.ArrayC<t.TypeC<{
        uri: t.StringC;
        type: t.StringC;
        name: t.StringC;
        packageName: t.StringC;
        author: t.StringC;
        objectTypeId: t.UnionC<[t.UndefinedC, t.StringC]>;
        findings: t.ArrayC<t.TypeC<{
            uri: t.StringC;
            location: t.TypeC<{
                uri: t.StringC;
                query: t.UnionC<[t.UndefinedC, t.RecordC<t.StringC, t.StringC>]>;
                range: t.TypeC<{
                    start: t.TypeC<{
                        line: t.NumberC;
                        column: t.NumberC;
                    }>;
                    end: t.TypeC<{
                        line: t.NumberC;
                        column: t.NumberC;
                    }>;
                }>;
                hashparms: t.UnionC<[t.UndefinedC, t.RecordC<t.StringC, t.StringC>]>;
            }>;
            priority: t.NumberC;
            checkId: t.StringC;
            checkTitle: t.StringC;
            messageId: t.StringC;
            messageTitle: t.StringC;
            exemptionApproval: t.StringC;
            exemptionKind: t.UnionC<[t.LiteralC<"A">, t.LiteralC<"I">, t.LiteralC<"">, t.StringC]>;
            quickfixInfo: t.UnionC<[t.UndefinedC, t.StringC]>;
            link: t.TypeC<{
                href: t.StringC;
                rel: t.StringC;
                type: t.StringC;
            }>;
        }>>;
    }>>;
}>;
declare const atcUser: t.TypeC<{
    id: t.StringC;
    title: t.StringC;
}>;
export type AtcRunResult = Clean<t.TypeOf<typeof atcRunResult>>;
export type AtcCustomizing = Clean<t.TypeOf<typeof atcCustomizingi>>;
export type AtcWorkList = Clean<t.TypeOf<typeof atcWorklist>>;
export type AtcUser = Clean<t.TypeOf<typeof atcUser>>;
export type AtcProposal = Clean<t.TypeOf<typeof atcProposal>>;
export type AtcProposalMessage = Clean<t.TypeOf<typeof atcProposalMessage>>;
export declare const isProposalMessage: t.Is<{
    type: string;
    message: string;
}>;
export declare function atcCustomizing(h: AdtHTTP): Promise<AtcCustomizing>;
export declare function atcCheckVariant(h: AdtHTTP, variant: string): Promise<string>;
export declare function createAtcRun(h: AdtHTTP, variant: string, mainUrl: string, maxResults?: number): Promise<AtcRunResult>;
export declare function atcWorklists(h: AdtHTTP, runResultId: string, timestamp?: number, usedObjectSet?: string, includeExemptedFindings?: boolean): Promise<AtcWorkList>;
export declare function atcUsers(h: AdtHTTP): Promise<AtcUser[]>;
export declare function atcExemptProposal(h: AdtHTTP, markerId: string): Promise<AtcProposal | AtcProposalMessage>;
export declare function atcRequestExemption(h: AdtHTTP, proposal: AtcProposal): Promise<AtcProposalMessage>;
export declare function atcContactUri(h: AdtHTTP, findingUri: string): Promise<string>;
export declare function atcChangeContact(h: AdtHTTP, itemUri: string, userId: string): Promise<void>;
export {};
//# sourceMappingURL=atc.d.ts.map