@types/serverless

constructor(config?: {});

classes: Serverless.Classes;

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

config: Serverless.Config;

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

configurationFilename: string;

pluginManager: PluginManager;

providers: {};

resources: AwsProvider.Resources;

serverlessDirPath: string;

service: Service;

serviceDir: string;

utils: Utils;

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

version: string;

yamlParser: YamlParser;

getProvider: (name: string) => AwsProvider;

getVersion: () => string;

init: () => Promise<any>;

run: () => Promise<any>;

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

Error: typeof ServerlessError;

serviceDir: string;

servicePath: string;

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

events: AwsProvider.Event[];

memorySize?: number | undefined;

name?: string | undefined;

package?: Package | undefined;

reservedConcurrency?: number | undefined;

runtime?: string | undefined;

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

timeout?: number | undefined;

handler: string;

image: string;

bold?: boolean | undefined;

color?: string | undefined;

entity?: string | undefined;

underline?: boolean | undefined;

extraServicePath?: string | undefined;

function?: string | undefined;

noDeploy?: boolean | undefined;

region?: string | undefined;

stage?: string | undefined;

verbose?: boolean | undefined;

watch?: boolean | undefined;

[key: string]: string | boolean | string[] | undefined;

artifact?: string | undefined;

exclude?: string[] | undefined;

include?: string[] | undefined;

individually?: boolean | undefined;

patterns?: string[] | undefined;