• Version 3.12.22
  • Published
  • 43.2 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 classes

      classes: Serverless.Classes;

        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 configurationFilename

              configurationFilename: string;

                property pluginManager

                pluginManager: PluginManager;

                  property providers

                  providers: {};

                    property resources

                    resources: AwsProvider.Resources;

                      property serverlessDirPath

                      serverlessDirPath: string;

                        property service

                        service: Service;

                          property serviceDir

                          serviceDir: string;

                            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 Classes

                                              interface Classes {}

                                                property Error

                                                Error: typeof ServerlessError;

                                                  interface Config

                                                  interface Config {}

                                                    property serviceDir

                                                    serviceDir: string;

                                                      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 {}
                                                                                              • CLI options provided to the command

                                                                                                Example 1

                                                                                                // serverless --verbose --stage prod { verbose: true, stage: 'prod' }

                                                                                              property extraServicePath

                                                                                              extraServicePath?: string | undefined;

                                                                                                property function

                                                                                                function?: string | undefined;

                                                                                                  property noDeploy

                                                                                                  noDeploy?: boolean | undefined;

                                                                                                    property region

                                                                                                    region?: string | undefined;

                                                                                                      property stage

                                                                                                      stage?: string | undefined;

                                                                                                        property verbose

                                                                                                        verbose?: boolean | undefined;

                                                                                                          property watch

                                                                                                          watch?: boolean | undefined;

                                                                                                            index signature

                                                                                                            [key: string]: string | boolean | string[] | 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>