• Version 3.12.11
  • Published
  • 39.7 kB
  • No dependencies
  • MIT license


npm i @types/serverless
yarn add @types/serverless
pnpm add @types/serverless


TypeScript definitions for serverless



class Serverless

class Serverless {}


    constructor(config?: {});

      property cli

      cli: {
      log(message: string, entity?: string, options?: Serverless.LogOptions): null;

        property config

        config: Serverless.Config;

          property configSchemaHandler

          configSchemaHandler: {
          defineCustomProperties(schema: unknown): void;
          provider: string,
          event: string,
          schema: Record<string, unknown>
          ): void;
          provider: string,
          existingEvent: string,
          schema: unknown
          ): void;
          defineFunctionProperties(provider: string, schema: unknown): void;
          defineProvider(provider: string, options?: Record<string, unknown>): void;
          provider: string,
          schema: Record<string, unknown>
          ): void;

            property pluginManager

            pluginManager: PluginManager;

              property providers

              providers: {};

                property resources

                resources: AwsProvider.Resources;

                  property serverlessDirPath

                  serverlessDirPath: string;

                    property service

                    service: Service;

                      property utils

                      utils: Utils;

                        property variables

                        variables: { populateService(): Promise<any> };

                          property version

                          version: string;

                            property yamlParser

                            yamlParser: YamlParser;

                              method getProvider

                              getProvider: (name: string) => AwsProvider;

                                method getVersion

                                getVersion: () => string;

                                  method init

                                  init: () => Promise<any>;

                                    method run

                                    run: () => Promise<any>;

                                      method setProvider

                                      setProvider: (name: string, provider: AwsProvider) => null;


                                        interface Config

                                        interface Config {}

                                          property servicePath

                                          servicePath: string;

                                            interface FunctionDefinition

                                            interface FunctionDefinition {}

                                              property environment

                                              environment?: { [name: string]: string } | undefined;

                                                property events

                                                events: AwsProvider.Event[];

                                                  property memorySize

                                                  memorySize?: number | undefined;

                                                    property name

                                                    name?: string | undefined;

                                                      property package

                                                      package?: Package | undefined;

                                                        property reservedConcurrency

                                                        reservedConcurrency?: number | undefined;

                                                          property runtime

                                                          runtime?: string | undefined;

                                                            property tags

                                                            tags?: { [key: string]: string } | undefined;

                                                              property timeout

                                                              timeout?: number | undefined;

                                                                interface FunctionDefinitionHandler

                                                                interface FunctionDefinitionHandler extends FunctionDefinition {}

                                                                  property handler

                                                                  handler: string;

                                                                    interface FunctionDefinitionImage

                                                                    interface FunctionDefinitionImage extends FunctionDefinition {}

                                                                      property image

                                                                      image: string;

                                                                        interface LogOptions

                                                                        interface LogOptions {}

                                                                          property bold

                                                                          bold?: boolean | undefined;

                                                                            property color

                                                                            color?: string | undefined;

                                                                              property entity

                                                                              entity?: string | undefined;

                                                                                property underline

                                                                                underline?: boolean | undefined;

                                                                                  interface Options

                                                                                  interface Options {}

                                                                                    property extraServicePath

                                                                                    extraServicePath?: string | undefined;

                                                                                      property function

                                                                                      function?: string | undefined;

                                                                                        property noDeploy

                                                                                        noDeploy?: boolean | undefined;

                                                                                          property region

                                                                                          region: string | null;

                                                                                            property stage

                                                                                            stage: string | null;

                                                                                              property verbose

                                                                                              verbose?: boolean | undefined;

                                                                                                property watch

                                                                                                watch?: boolean | undefined;

                                                                                                  interface Package

                                                                                                  interface Package {}

                                                                                                    property artifact

                                                                                                    artifact?: string | undefined;

                                                                                                      property exclude

                                                                                                      exclude?: string[] | undefined;
                                                                                                      • Deprecated

                                                                                                        use patterns instead

                                                                                                      property include

                                                                                                      include?: string[] | undefined;
                                                                                                      • Deprecated

                                                                                                        use patterns instead

                                                                                                      property individually

                                                                                                      individually?: boolean | undefined;

                                                                                                        property patterns

                                                                                                        patterns?: string[] | undefined;

                                                                                                          Type Aliases

                                                                                                          type Event

                                                                                                          type Event = AwsProvider.Event | object;

                                                                                                            Package Files (1)

                                                                                                            Dependencies (0)

                                                                                                            No dependencies.

                                                                                                            Dev Dependencies (0)

                                                                                                            No dev dependencies.

                                                                                                            Peer Dependencies (0)

                                                                                                            No peer dependencies.


                                                                                                            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/@types/serverless.

                                                                                                            • Markdown
                                                                                                            • HTML
                                                                                                              <a href="https://www.jsdocs.io/package/@types/serverless"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>