Logo for jsDocs.io

@snyk/cli-interface

  • Version 2.14.0
  • 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

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;

                                                                                                                                                      property targetRuntime

                                                                                                                                                      targetRuntime?: 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 (1)

                                                                                                                                                                                        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>