@snyk/cli-interface

  • Version 2.11.1
  • Published
  • 20.8 kB
  • 1 dependency
  • Apache-2.0 license

Install

npm i @snyk/cli-interface
yarn add @snyk/cli-interface
pnpm add @snyk/cli-interface

Overview

Snyk CLI interface definitions

Index

Namespaces

namespace legacyCommon

module 'legacy/common.d.ts' {}

    interface CallGraphError

    interface CallGraphError {}

      property innerError

      innerError: Error;

        property message

        message: string;

          interface DepTree

          interface DepTree extends DepTreeDep {}

            property docker

            docker?: any;

              property files

              files?: any;

                property packageFormatVersion

                packageFormatVersion?: string;

                  property policy

                  policy?: string;

                    property targetFile

                    targetFile?: string;

                      property targetOS

                      targetOS?: {
                      name: string;
                      version: string;
                      };

                        property type

                        type?: string;

                          interface DepTreeDep

                          interface DepTreeDep {}

                            property dependencies

                            dependencies?: {
                            [depName: string]: DepTreeDep;
                            };

                              property labels

                              labels?: {
                              [key: string]: string;
                              };

                                property name

                                name?: string;

                                  property version

                                  version?: string;

                                    interface ScannedProject

                                    interface ScannedProject {}

                                      property callGraph

                                      callGraph?: CallGraphResult;

                                        property depGraph

                                        depGraph?: DepGraph;

                                          property depTree

                                          depTree?: DepTree;

                                            property meta

                                            meta?: any;

                                              property targetFile

                                              targetFile?: string;

                                                type CallGraph

                                                type CallGraph = graphlib.Graph;

                                                  type CallGraphResult

                                                  type CallGraphResult = CallGraph | CallGraphError;

                                                    type SupportedPackageManagers

                                                    type SupportedPackageManagers =
                                                    | 'rubygems' // Ruby
                                                    | 'npm'
                                                    | 'yarn' // Node.js
                                                    | 'maven'
                                                    | 'sbt'
                                                    | 'gradle' // JVM
                                                    | 'golangdep'
                                                    | 'govendor'
                                                    | 'gomodules' // Go
                                                    | 'pip' // Python
                                                    | 'nuget'
                                                    | 'paket' // .Net
                                                    | 'composer' // PHP
                                                    | 'rpm'
                                                    | 'apk'
                                                    | 'deb'
                                                    | 'dockerfile';

                                                      namespace legacyMonitor

                                                      module 'legacy/monitor.d.ts' {}

                                                        interface MonitorBody

                                                        interface MonitorBody {}

                                                          property dependencyGraph

                                                          dependencyGraph?: DepGraph;

                                                            property meta

                                                            meta: MonitorMeta;

                                                              property package

                                                              package?: DepTree;

                                                                property policy

                                                                policy: string;

                                                                  property targetFile

                                                                  targetFile: string;

                                                                    interface MonitorMeta

                                                                    interface MonitorMeta {}

                                                                      property ci

                                                                      ci: boolean;

                                                                        property dockerBaseImage

                                                                        dockerBaseImage?: string;

                                                                          property dockerImageId

                                                                          dockerImageId?: string;

                                                                            property hostname

                                                                            hostname: string;

                                                                              property id

                                                                              id: string;

                                                                                property master

                                                                                master: boolean;

                                                                                  property method

                                                                                  method?: string;

                                                                                    property name

                                                                                    name: string;

                                                                                      property node

                                                                                      node: string;

                                                                                        property org

                                                                                        org?: string;

                                                                                          property pid

                                                                                          pid: number;

                                                                                            property pluginName

                                                                                            pluginName: string;

                                                                                              property pluginRuntime

                                                                                              pluginRuntime: string;

                                                                                                property projectName

                                                                                                projectName: string;

                                                                                                  property version

                                                                                                  version: string;

                                                                                                    namespace legacyPlugin

                                                                                                    module 'legacy/plugin.d.ts' {}

                                                                                                      function adaptSingleProjectPlugin

                                                                                                      adaptSingleProjectPlugin: (plugin: SingleSubprojectPlugin) => Plugin;

                                                                                                        function isMultiResult

                                                                                                        isMultiResult: (res: InspectResult) => res is MultiProjectResult;

                                                                                                          function isMultiSubProject

                                                                                                          isMultiSubProject: (
                                                                                                          options: InspectOptions
                                                                                                          ) => options is MultiSubprojectInspectOptions;

                                                                                                            interface BaseInspectOptions

                                                                                                            interface BaseInspectOptions {}

                                                                                                              property args

                                                                                                              args?: string[];

                                                                                                                property dev

                                                                                                                dev?: boolean;

                                                                                                                  property skipUnresolved

                                                                                                                  skipUnresolved?: boolean;

                                                                                                                    property useDepGraph

                                                                                                                    useDepGraph?: boolean;

                                                                                                                      interface MultiProjectResult

                                                                                                                      interface MultiProjectResult {}

                                                                                                                        property plugin

                                                                                                                        plugin: PluginMetadata;

                                                                                                                          property scannedProjects

                                                                                                                          scannedProjects: ScannedProject[];

                                                                                                                            interface MultiSubprojectInspectOptions

                                                                                                                            interface MultiSubprojectInspectOptions extends BaseInspectOptions {}

                                                                                                                              property allSubProjects

                                                                                                                              allSubProjects: true;

                                                                                                                                interface Plugin

                                                                                                                                interface Plugin extends SingleSubprojectPlugin {}

                                                                                                                                  method inspect

                                                                                                                                  inspect: {
                                                                                                                                  (
                                                                                                                                  root: string,
                                                                                                                                  targetFile?: string,
                                                                                                                                  options?: InspectOptions
                                                                                                                                  ): Promise<InspectResult>;
                                                                                                                                  (
                                                                                                                                  root: string,
                                                                                                                                  targetFile?: string,
                                                                                                                                  options?: SingleSubprojectInspectOptions
                                                                                                                                  ): Promise<SinglePackageResult>;
                                                                                                                                  (
                                                                                                                                  root: string,
                                                                                                                                  targetFile: string,
                                                                                                                                  options: MultiSubprojectInspectOptions
                                                                                                                                  ): Promise<MultiProjectResult>;
                                                                                                                                  };

                                                                                                                                    interface PluginMetadata

                                                                                                                                    interface PluginMetadata {}

                                                                                                                                      property dockerImageId

                                                                                                                                      dockerImageId?: any;

                                                                                                                                        property imageLayers

                                                                                                                                        imageLayers?: any;

                                                                                                                                          property meta

                                                                                                                                          meta?: {
                                                                                                                                          allSubProjectNames?: string[];
                                                                                                                                          versionBuildInfo?: VersionBuildInfo;
                                                                                                                                          targetFile?: string;
                                                                                                                                          };

                                                                                                                                            property name

                                                                                                                                            name: string;

                                                                                                                                              property packageFormatVersion

                                                                                                                                              packageFormatVersion?: string;

                                                                                                                                                property packageManager

                                                                                                                                                packageManager?: SupportedPackageManagers;

                                                                                                                                                  property runtime

                                                                                                                                                  runtime?: string;

                                                                                                                                                    property targetFile

                                                                                                                                                    targetFile?: string;

                                                                                                                                                      interface SinglePackageResult

                                                                                                                                                      interface SinglePackageResult {}

                                                                                                                                                        property callGraph

                                                                                                                                                        callGraph?: CallGraphResult;

                                                                                                                                                          property dependencyGraph

                                                                                                                                                          dependencyGraph?: DepGraph;

                                                                                                                                                            property meta

                                                                                                                                                            meta?: {
                                                                                                                                                            gradleProjectName?: string;
                                                                                                                                                            versionBuildInfo?: VersionBuildInfo;
                                                                                                                                                            };

                                                                                                                                                              property package

                                                                                                                                                              package: DepTree;

                                                                                                                                                                property plugin

                                                                                                                                                                plugin: PluginMetadata;

                                                                                                                                                                  interface SingleSubprojectInspectOptions

                                                                                                                                                                  interface SingleSubprojectInspectOptions extends BaseInspectOptions {}

                                                                                                                                                                    property subProject

                                                                                                                                                                    subProject?: string;

                                                                                                                                                                      interface SingleSubprojectPlugin

                                                                                                                                                                      interface SingleSubprojectPlugin {}

                                                                                                                                                                        method inspect

                                                                                                                                                                        inspect: (
                                                                                                                                                                        root: string,
                                                                                                                                                                        targetFile?: string,
                                                                                                                                                                        options?: SingleSubprojectInspectOptions
                                                                                                                                                                        ) => Promise<SinglePackageResult>;

                                                                                                                                                                          method pluginName

                                                                                                                                                                          pluginName: () => string;

                                                                                                                                                                            interface VersionBuildInfo

                                                                                                                                                                            interface VersionBuildInfo {}

                                                                                                                                                                              property gradleVersion

                                                                                                                                                                              gradleVersion?: string;

                                                                                                                                                                                property metaBuildVersion

                                                                                                                                                                                metaBuildVersion: {
                                                                                                                                                                                [index: string]: string;
                                                                                                                                                                                };

                                                                                                                                                                                  type InspectOptions

                                                                                                                                                                                  type InspectOptions = SingleSubprojectInspectOptions | MultiSubprojectInspectOptions;

                                                                                                                                                                                    type InspectResult

                                                                                                                                                                                    type InspectResult = SinglePackageResult | MultiProjectResult;

                                                                                                                                                                                      Package Files (4)

                                                                                                                                                                                      Dependencies (1)

                                                                                                                                                                                      Dev Dependencies (3)

                                                                                                                                                                                      Peer Dependencies (3)

                                                                                                                                                                                      Badge

                                                                                                                                                                                      To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                      You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@snyk/cli-interface.

                                                                                                                                                                                      • Markdown
                                                                                                                                                                                        [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@snyk/cli-interface)
                                                                                                                                                                                      • HTML
                                                                                                                                                                                        <a href="https://www.jsdocs.io/package/@snyk/cli-interface"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>