@flosum/salesforce 1.17.10-test.1 → 1.17.10

package/dist/typings/interfaces/metadata/dependency/layout.interface.d.ts

@@ -0,0 +1,59 @@
+import { PlatformActionType } from '../../../enums';
+export interface QuickActionItem {
+    quickActionName: string;
+}
+export interface QuickAction {
+    quickActionListItems: QuickActionItem[];
+}
+export interface PlatformActionItem {
+    actionName: string;
+    actionType: PlatformActionType;
+    sortOrder: number;
+    subtype?: string;
+}
+export interface PlatformAction {
+    actionListContext: string;
+    platformActionListItems?: PlatformActionItem[];
+    relatedSourceEntity?: string;
+}
+export interface LayoutItem {
+    behavior?: string;
+    field?: string;
+    canvas?: string;
+    component?: string;
+    customLink?: string;
+    emptySpace?: boolean;
+    height?: number;
+    page?: string;
+    scontrol?: string;
+    showLabel?: boolean;
+    showScrollbars?: boolean;
+    width?: string;
+}
+export interface LayoutColumn {
+    layoutItems?: LayoutItem[];
+}
+export interface LayoutSection {
+    customLabel: boolean;
+    detailHeading: boolean;
+    editHeading: boolean;
+    label: string;
+    layoutColumns?: LayoutColumn[];
+    style: string;
+}
+export interface RelatedListItem {
+    relatedList: string;
+    fields?: string[];
+    customButtons?: string[];
+}
+export interface LayoutDetails {
+    fullName?: string;
+    customButtons?: string[];
+    quickActionList?: QuickAction;
+    platformActionList?: PlatformAction;
+    layoutSections: LayoutSection[];
+    relatedLists?: RelatedListItem[];
+}
+export interface Layout {
+    Layout: LayoutDetails;
+}

package/dist/typings/interfaces/metadata/dependency/list-view.interface.d.ts

@@ -0,0 +1,44 @@
+export interface Filter {
+    field: string;
+    operation: string;
+    value: string;
+}
+export interface SharedTo {
+    allCustomerPortalUsers?: string;
+    allInternalUsers?: string;
+    allPartnerUsers?: string;
+    channelProgramGroup?: string;
+    channelProgramGroups?: string[];
+    group?: string[];
+    guestUser?: string[];
+    groups?: string[];
+    managerSubordinates?: string[];
+    managers?: string[];
+    portalRole?: string[];
+    portalRoleandSubordinates?: string[];
+    role?: string[];
+    roleAndSubordinates?: string[];
+    roleAndSubordinatesInternal?: string[];
+    roles?: string[];
+    rolesAndSubordinates?: string[];
+    territories?: string[];
+    territoriesAndSubordinates?: string[];
+    territory?: string[];
+    territoryAndSubordinates?: string[];
+    queue?: string[];
+}
+export interface ListViewDetails {
+    fullName: string;
+    columns?: string[];
+    booleanFilter?: string;
+    division?: string;
+    filterScope: string;
+    filters?: Filter[];
+    language?: string;
+    label: string;
+    queue?: string;
+    sharedTo?: SharedTo;
+}
+export interface ListView {
+    ListView: ListViewDetails;
+}

package/dist/typings/interfaces/metadata/dependency/record-type.interface.d.ts

@@ -0,0 +1,20 @@
+export interface RecordType {
+    RecordType: RecordTypeDetails;
+}
+export interface RecordTypeDetails {
+    active: boolean;
+    businessProcess?: string;
+    compactLayoutAssignment?: string;
+    description?: string;
+    fullName: string;
+    label: string;
+    picklistValues?: RecordTypePicklistValue[];
+}
+export interface RecordTypePicklistValue {
+    picklist: string;
+    values?: PicklistValue[];
+}
+export interface PicklistValue {
+    fullName: string;
+    default: boolean;
+}

package/dist/typings/interfaces/metadata/deploy-metadata.interfaces.d.ts

@@ -0,0 +1,121 @@
+import { BaseSoapCommandOptions } from '..';
+import { DeployProblemType, DeployTestLevel } from '../../enums/deploy.metadata.enums';
+export declare type CommandDeployMetadataSoapBody = {
+    'met:deploy': {
+        'met:ZipFile': string;
+        'met:DeployOptions'?: CommandDeployMetadataSoapDeployOptionsBody;
+    };
+};
+export declare type CommandDeployMetadataSoapDeployOptionsBody = {
+    'met:checkOnly'?: boolean;
+    'met:singlePackage'?: boolean;
+    'met:allowMissingFiles'?: boolean;
+    'met:autoUpdatePackage'?: boolean;
+    'met:ignoreWarnings'?: boolean;
+    'met:performRetrieve'?: boolean;
+    'met:purgeOnDelete'?: boolean;
+    'met:rollbackOnError'?: boolean;
+    'met:runAllTests'?: boolean;
+    'met:testLevel'?: DeployTestLevel;
+    'met:runTests'?: string[];
+};
+export declare type CommandDeployMetadataSoapOptions = BaseSoapCommandOptions & {
+    file: string;
+    deployOptions?: CommandDeployMetadataSoapDeployOptions;
+};
+export declare type CommandDeployMetadataSoapDeployOptions = {
+    checkOnly?: boolean;
+    singlePackage?: boolean;
+    allowMissingFiles?: boolean;
+    autoUpdatePackage?: boolean;
+    ignoreWarnings?: boolean;
+    performRetrieve?: boolean;
+    purgeOnDelete?: boolean;
+    rollbackOnError?: boolean;
+    runAllTests?: boolean;
+    testLevel?: DeployTestLevel;
+    runTests?: string[];
+};
+export declare type CommandDeployMetadataSoapRequestResponseResult = {
+    done: boolean;
+    id: string;
+    state: string;
+};
+export declare type CommandDeployMetadataSoapRequestResponse = {
+    deployResponse: {
+        result: CommandDeployMetadataSoapRequestResponseResult;
+    };
+};
+export declare type CommandDeployMetadataSoapRequestResult = CommandDeployMetadataSoapRequestResponseResult;
+export declare type CheckDeployMetadataSoapStatusBody = {
+    'met:checkDeployStatus': {
+        'met:asyncProcessId': string;
+        'met:includeDetails': boolean;
+    };
+};
+export declare type CheckDeploySoapStatusCommandOptions = BaseSoapCommandOptions & {
+    asyncProcessId: string;
+    includeDetails: boolean;
+};
+export declare type DeployMetadataMessage = {
+    changed: boolean;
+    columnNumber: number;
+    componentType: string;
+    created: boolean;
+    createdDate: string;
+    deleted: boolean;
+    fileName: string;
+    fullName: string;
+    id: string;
+    lineNumber: string;
+    problem: string;
+    problemType: DeployProblemType;
+    success: boolean;
+};
+export declare type DeployMetadataStatusSoapDetails = {
+    runTestResult: {
+        numFailures: string;
+        numTestsRun: string;
+        totalTime: string;
+        failures?: DeployMetadataTestFailures[];
+    };
+    componentFailures: DeployMetadataMessage[];
+    componentSuccesses: DeployMetadataMessage[];
+};
+export declare type DeployMetadataTestFailures = {
+    id: string;
+    message: string;
+    methodName: string;
+    name: string;
+    namespace: string;
+    packageName: string;
+    stackTrace: string;
+    time: number;
+    type: string;
+};
+export declare type CheckDeployMetadataStatusResult = {
+    checkOnly: boolean;
+    createdBy: string;
+    createdByName: string;
+    createdDate: string;
+    details: DeployMetadataStatusSoapDetails;
+    done: boolean;
+    id: string;
+    ignoreWarnings: boolean;
+    lastModifiedDate: string;
+    numberComponentErrors: string;
+    numberComponentsDeployed: string;
+    numberComponentsTotal: string;
+    numberTestErrors: string;
+    numberTestsCompleted: string;
+    numberTestsTotal: string;
+    rollbackOnError: boolean;
+    runTestsEnabled: boolean;
+    status: string;
+    success: boolean;
+};
+export declare type CheckDeployMetadataSoapStatusRequestResponse = {
+    checkDeployStatusResponse: {
+        result: CheckDeployMetadataStatusResult;
+    };
+};

package/dist/typings/interfaces/metadata/describe-metadata.interfaces.d.ts

@@ -0,0 +1,32 @@
+import { MetadataType } from '../../enums';
+export declare type SoapDescribeMetadataSoapBody = {
+    'met:describeMetadata': {
+        'met:asOfVersion': string;
+    };
+};
+export declare type SoapDescribeMetadataResponse = {
+    describeMetadataResponse: {
+        result: SoapDescribeMetadataResult;
+    };
+};
+declare type DescribeMetadataResultProperties = {
+    organizationNamespace: string;
+    partialSaveAllowed: boolean;
+    testRequired: boolean;
+};
+export declare type DescribeMetadataItem = {
+    directoryName: string;
+    inFolder: boolean;
+    metaFile: boolean;
+    suffix: string;
+    xmlName: MetadataType;
+    childXmlNames?: MetadataType[];
+    parentXmlName?: MetadataType;
+};
+export declare type SoapDescribeMetadataResult = DescribeMetadataResultProperties & {
+    metadataObjects: DescribeMetadataItem[];
+};
+export declare type DescribeMetadataResult = DescribeMetadataResultProperties & {
+    metadataObjects: Record<string, DescribeMetadataItem>;
+};
+export {};

package/dist/typings/interfaces/metadata/list-metadata.interfaces.d.ts

@@ -0,0 +1,51 @@
+import { BaseSoapCommandOptions } from './base.interfaces';
+import { MetadataType } from '../../enums/type.metadata.enum';
+import { ManageableState } from '../../enums';
+export declare type ListMetadataSoapCommandOptions = BaseSoapCommandOptions & {
+    types: ListMetadataType[];
+};
+export declare type ListMetadataType = {
+    metadataType: string;
+    folder?: string;
+};
+export declare type ListMetadataSoapBody = {
+    'met:listMetadata': {
+        'met:queries': {
+            'met:folder': string;
+            'met:type': string;
+        }[];
+        'met:asOfVersion': string;
+    };
+};
+export declare type SoapListMetadataResponse = {
+    listMetadataResponse: {
+        result: ListMetadataItem[];
+    };
+};
+export declare type ListMetadataItem = {
+    createdById: string;
+    createdByName: string;
+    createdDate: string;
+    fileName: string;
+    fullName: string;
+    id: string;
+    lastModifiedById: string;
+    lastModifiedByName: string;
+    lastModifiedDate: string;
+    manageableState: ManageableState;
+    namespacePrefix?: string;
+    type: MetadataType;
+};
+export declare type MetadataItemData = {
+    listMetadataItem: ListMetadataItem;
+    manifest: {
+        type: MetadataType;
+        member: string;
+    };
+    uniqueName?: string;
+};
+export declare type ListMetadataItemDetails = {
+    main?: MetadataItemData;
+    child?: MetadataItemData[];
+};
+export declare type ListMetadataCommandResult = ListMetadataItem[];

package/dist/typings/interfaces/metadata/read-metadata.interfaces.d.ts

@@ -0,0 +1,29 @@
+import { BaseSoapCommandOptions, RetrieveType } from '..';
+import { MetadataType } from '../../enums';
+export declare type ReadMetadataSoapBody = {
+    'met:readMetadata': {
+        'met:type': string;
+        'met:fullNames': string[];
+    };
+};
+export declare type SoapReadMetadataResponse<T extends ReadMetadataRecord> = {
+    readMetadataResponse: {
+        result: {
+            records: T[];
+        };
+    };
+};
+export declare type ReadMetadataSoapCommandOptions = BaseSoapCommandOptions & {
+    type: RetrieveType;
+    organizationNamespace?: string;
+};
+export declare type ReadMetadataRecord = {
+    $: Record<string, string>;
+    name?: string;
+    fullName: string;
+};
+export declare type ReadMetadataResult = {
+    xml: string;
+    type: MetadataType | string;
+    fullName: string;
+};

package/dist/typings/interfaces/metadata/retrieve-metadata.interfaces.d.ts

@@ -0,0 +1,102 @@
+/// <reference types="node" />
+import { BaseSoapCommandOptions } from './base.interfaces';
+import { ListMetadataItem } from './list-metadata.interfaces';
+import { RetrieveResultStatus } from '../../enums/retreive.metadata.enums';
+import { DescribeMetadataItem } from '..';
+import { MetadataType } from '../../enums';
+export declare type RetrieveSoapCommandOptions = BaseSoapCommandOptions & {
+    types: RetrieveType[];
+};
+export declare type RetrieveMetadataSoapBody = {
+    'met:retrieve': {
+        'met:retrieveRequest': {
+            'met:apiVersion': string;
+            'met:singlePackage': boolean;
+            'met:unpackaged': {
+                'met:types': {
+                    'met:name': string;
+                    'met:members': string[];
+                }[];
+            };
+        };
+    };
+};
+export declare type SoapRetrieveMetadataResponse = {
+    retrieveResponse: {
+        result: RetrieveMetadataResult;
+    };
+};
+export declare type RetrieveMetadataResult = {
+    done: boolean;
+    id: string;
+    state: string;
+};
+export declare type RetrieveType = {
+    name: MetadataType | string;
+    members: string[];
+};
+export declare type CheckRetrieveStatusSoapCommandOptions = BaseSoapCommandOptions & {
+    asyncProcessId: string;
+};
+export declare type CheckRetrieveStatusSoapBody = {
+    'met:checkRetrieveStatus': {
+        'met:asyncProcessId': string;
+        'met:includeZip': boolean;
+    };
+};
+export declare type SoapCheckRetrieveMetadataStatusResponse = {
+    checkRetrieveStatusResponse: {
+        result: SoapCheckRetrieveMetadataStatusResult;
+    };
+};
+export declare type SoapCheckRetrieveMetadataStatusResult = {
+    done: boolean;
+    fileProperties?: ListMetadataItem[];
+    id: string;
+    status: RetrieveResultStatus;
+    errorMessage?: string;
+    errorStatusCode?: string;
+    success: boolean;
+    zipFile?: string | any;
+    messages?: CheckRetrieveMetadataStatusMessage[];
+};
+export declare type CheckRetrieveMetadataStatusResult = SoapCheckRetrieveMetadataStatusResult & {
+    fileProperties: ListMetadataItem[];
+    messages?: CheckRetrieveMetadataStatusMessage[];
+};
+export declare type RetrieveMetadataZipResult = {
+    fileProperties: ListMetadataItem[];
+    zipFile: Buffer;
+    messages?: CheckRetrieveMetadataStatusMessage[];
+};
+export declare type CheckRetrieveMetadataStatusMessage = {
+    filename: string;
+    problem: string;
+};
+export declare type MetadataItem = DescribeMetadataItem & {
+    components: MetadataComponent[];
+};
+export interface MetadataComponent {
+    listMetadataItem: ListMetadataItem;
+    files: Record<string, Buffer>;
+}
+export declare type SoapRetrieveMetadataResult = {
+    items: Record<string, MetadataItem>;
+    warnings: CheckRetrieveMetadataStatusMessage[];
+};
+export declare type ContentFile = {
+    content: Buffer;
+    parsedXml?: Record<string, any>;
+};
+export declare type RetrieverResult = {
+    files: Record<string, ContentFile>;
+    warnings?: CheckRetrieveMetadataStatusMessage[];
+};
+export declare type File = {
+    path: string;
+    content: Buffer;
+};
+export declare type MetadataComponentResult = {
+    listMetadataItem: ListMetadataItem;
+    files: File[];
+};

package/dist/typings/interfaces/metadata/sf/base.sf-command-interfaces.d.ts

@@ -0,0 +1,3 @@
+export declare type BaseSfCommandOptions = {
+    cwd: string;
+};

package/dist/typings/interfaces/metadata/sf/code-analyzer.sf-command-interfaces.d.ts

@@ -0,0 +1,51 @@
+import { BaseSfCommandOptions } from '../..';
+import { SeverityThreshold } from '../../../enums/code-analyzer-sf-command.enums';
+export interface CodeAnalyzerSfCommandOptions extends BaseSfCommandOptions {
+    workspaces?: string[];
+    target?: string;
+    ruleSelectors?: string[];
+    severityThreshold?: SeverityThreshold;
+    configFile?: string;
+}
+export interface CodeAnalyzerSfCommandResult {
+    runDir: string;
+    violationCounts: ViolationCounts;
+    versions: Versions;
+    violations: Violation[];
+}
+export interface ViolationCounts {
+    total: number;
+    sev1: number;
+    sev2: number;
+    sev3: number;
+    sev4: number;
+    sev5: number;
+}
+export interface Versions {
+    'code-analyzer': string;
+    cpd: string;
+    eslint: string;
+    flow: string;
+    pmd: string;
+    'retire-js': string;
+    regex: string;
+    sfge: string;
+}
+export interface Violation {
+    rule: string;
+    engine: string;
+    severity: number;
+    tags: string[];
+    primaryLocationIndex: number;
+    locations: Location[];
+    message: string;
+    resources: string;
+}
+export interface Location {
+    file: string;
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+    comment: string;
+}

package/dist/typings/interfaces/metadata/sf/config-set.sf-command-interfaces.d.ts

@@ -0,0 +1,4 @@
+import { BaseSfCommandOptions } from './base.sf-command-interfaces';
+export interface ConfigSetSfCommandOptions extends BaseSfCommandOptions {
+    orgInstanceUrl?: string;
+}

package/dist/typings/interfaces/metadata/sf/convert.sf-command-interfaces.d.ts

@@ -0,0 +1,12 @@
+import { MetadataType } from '../../../enums';
+import { BaseSfCommandOptions } from './base.sf-command-interfaces';
+export interface ConvertMdApiSfCommandOptions extends BaseSfCommandOptions {
+    rootDir: string;
+    outputDir: string;
+}
+export declare type ConvertMdApiSfCommandResult = {
+    fullName: string;
+    type: MetadataType;
+    filePath: string;
+    state: string;
+};

package/dist/typings/interfaces/metadata/sf/create-project.sf-command-interfaces.d.ts

@@ -0,0 +1,4 @@
+import { BaseSfCommandOptions } from './base.sf-command-interfaces';
+export interface CreateProjectSfCommandOptions extends BaseSfCommandOptions {
+    projectName: string;
+}

package/dist/typings/interfaces/metadata/sf/deploy.sf-command-interfaces.d.ts

@@ -0,0 +1,136 @@
+import { MetadataType, TestLevel } from '../../../enums';
+import { BaseSfCommandOptions } from './base.sf-command-interfaces';
+export interface DeploySfCommandOptions extends BaseSfCommandOptions {
+    sourceDir?: string;
+    targetOrg?: string;
+    dryRun?: boolean;
+    ignoreConflicts?: boolean;
+    ignoreErrors?: boolean;
+    ignoreWarnings?: boolean;
+    testLevel?: TestLevel;
+    tests?: string[];
+    manifest?: string;
+    preDestructiveChanges?: string;
+    postDestructiveChanges?: string;
+}
+export declare type DeploySfCommandComponentResult = {
+    changed: boolean;
+    componentType: MetadataType;
+    created: boolean;
+    createdDate: string;
+    deleted: boolean;
+    fileName: string;
+    fullName: string;
+    problem?: string;
+    problemType?: string;
+    success: boolean;
+};
+export declare type DeploySfCommandNotCoveredLocationsInfo = {
+    column: number;
+    line: number;
+    numExecutions: number;
+    time: number;
+};
+export declare type DeploySfCommandCodeCoverageInfo = {
+    id: string;
+    name: string;
+    namespace: string | null;
+    numLocations: number;
+    numLocationsNotCovered: number;
+    type: string;
+    locationsNotCovered: DeploySfCommandNotCoveredLocationsInfo[];
+};
+export declare type DeploySfCommandCodeCoverageWarning = {
+    id: string;
+    message: string;
+    name: string;
+    namespace: string | null;
+};
+export declare type DeploySfCommandTestFailureInfo = {
+    id: string;
+    message: string;
+    methodName: string;
+    name: string;
+    namespace: string;
+    packageName: string;
+    stackTrace: string;
+    time: number;
+    type: string;
+};
+export declare type DeploySfCommandFlowCoverageInfo = {
+    flowId: string;
+    flowName: string;
+    flowNamespace: string;
+    numElements: number;
+    numElementsNotCovered: number;
+    processType: string;
+    elementsNotCovered: string[];
+};
+export declare type DeploySfCommandFlowCoverageWarning = {
+    id: string;
+    message: string;
+    name: string;
+    namespace: string;
+};
+export declare type DeploySfCommandTestSuccessInfo = {
+    id: string;
+    methodName: string;
+    name: string;
+    namespace: string | null;
+    time: number;
+};
+export declare type DeploySfCommandRunTestResult = {
+    numFailures: number;
+    numTestsRun: number;
+    totalTime: number;
+    codeCoverage: DeploySfCommandCodeCoverageInfo[];
+    codeCoverageWarnings: DeploySfCommandCodeCoverageWarning[];
+    failures: DeploySfCommandTestFailureInfo[];
+    flowCoverage: DeploySfCommandFlowCoverageInfo[];
+    flowCoverageWarnings: DeploySfCommandFlowCoverageWarning[];
+    successes: DeploySfCommandTestSuccessInfo[];
+};
+export declare type DeploySfCommandResultDetails = {
+    componentFailures: DeploySfCommandComponentResult[];
+    componentSuccesses: DeploySfCommandComponentResult[];
+    runTestResult: DeploySfCommandRunTestResult;
+};
+export declare type DeploySfCommandFileInfo = {
+    fullName: string;
+    type: MetadataType;
+    state: string;
+    problemType?: string;
+    filePath: string;
+    lineNumber?: number;
+    columnNumber?: number;
+    error?: string;
+};
+export declare type DeploySfCommandResult = {
+    canceledBy?: string;
+    canceledByName?: string;
+    checkOnly: boolean;
+    completedDate: string;
+    createdBy: string;
+    createdByName: string;
+    createdDate: string;
+    details: DeploySfCommandResultDetails;
+    done: boolean;
+    id: string;
+    ignoreWarnings: boolean;
+    lastModifiedDate: string;
+    numberComponentErrors: number;
+    numberComponentsDeployed: number;
+    numberComponentsTotal: number;
+    numberTestErrors: number;
+    numberTestsCompleted: number;
+    numberTestsTotal: number;
+    rollbackOnError: boolean;
+    runTestsEnabled: boolean;
+    startDate: string;
+    status: string;
+    success: boolean;
+    files: DeploySfCommandFileInfo[];
+    zipSize: number;
+    zipFileCount: number;
+    deployUrl: string;
+};