@gramio/scenes/dist/index.d.ts

Scenes plugin for GramIO

import * as gramio from 'gramio';
import { MaybePromise, ContextType, Bot, ErrorDefinitions, DeriveDefinitions, Composer, AnyPlugin, UpdateName, MaybeArray, Handler, Context, Stringable, Plugin } from 'gramio';
import { Storage } from '@gramio/storage';
import { NextMiddleware } from 'middleware-io';

/** The Standard Schema interface. */
interface StandardSchemaV1<Input = unknown, Output = Input> {
    /** The Standard Schema properties. */
    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
}
declare namespace StandardSchemaV1 {
    /** The Standard Schema properties interface. */
    export interface Props<Input = unknown, Output = Input> {
        /** The version number of the standard. */
        readonly version: 1;
        /** The vendor name of the schema library. */
        readonly vendor: string;
        /** Validates unknown input values. */
        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
        /** Inferred types associated with the schema. */
        readonly types?: Types<Input, Output> | undefined;
    }
    /** The result interface of the validate function. */
    export type Result<Output> = SuccessResult<Output> | FailureResult;
    /** The result interface if validation succeeds. */
    export interface SuccessResult<Output> {
        /** The typed output value. */
        readonly value: Output;
        /** The non-existent issues. */
        readonly issues?: undefined;
    }
    /** The result interface if validation fails. */
    export interface FailureResult {
        /** The issues of failed validation. */
        readonly issues: ReadonlyArray<Issue>;
    }
    /** The issue interface of the failure output. */
    export interface Issue {
        /** The error message of the issue. */
        readonly message: string;
        /** The path of the issue, if any. */
        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
    }
    /** The path segment interface of the issue. */
    export interface PathSegment {
        /** The key representing a path segment. */
        readonly key: PropertyKey;
    }
    /** The Standard Schema types interface. */
    export interface Types<Input = unknown, Output = Input> {
        /** The input type of the schema. */
        readonly input: Input;
        /** The output type of the schema. */
        readonly output: Output;
    }
    /** Infers the input type of a Standard Schema. */
    export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
    /** Infers the output type of a Standard Schema. */
    export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
    export {  };
}

type Modify<Base, Mod> = Omit<Base, keyof Mod> & Mod;
type StateTypesDefault = Record<string | number, any>;
type UpdateData<T extends StateTypesDefault> = {};
interface ScenesOptions {
    storage?: Storage;
}
interface ScenesStorageData<Params = any, State = any> {
    name: string;
    params: Params;
    state: State;
    stepId: number;
    previousStepId: number;
    firstTime: boolean;
}
interface SceneUpdateState {
    /**
     * @default sceneData.stepId + 1
     */
    step?: number;
    firstTime?: boolean;
}
type SceneEnterHandler<Scene extends AnyScene = AnyScene> = (scene: Scene, ...args: Scene["~"]["params"] extends never ? [] : [params: Scene["~"]["params"]]) => Promise<void>;
interface EnterExit {
    enter: SceneEnterHandler;
    exit: () => MaybePromise<boolean>;
}
type SceneStepReturn = {
    id: number;
    previousId: number;
    firstTime: boolean;
    go: (stepId: number, firstTime?: boolean) => Promise<void>;
    next: () => Promise<void>;
    previous: () => Promise<void>;
};
interface InActiveSceneHandlerReturn<Params, State extends StateTypesDefault> extends EnterExit {
    state: State;
    params: Params;
    update: <T extends StateTypesDefault>(state: T, options?: SceneUpdateState) => Promise<UpdateData<T>>;
    step: SceneStepReturn;
    reenter: () => Promise<void>;
}
interface InUnknownScene<Params, State extends StateTypesDefault, GlobalScene extends AnyScene | null = null> extends InActiveSceneHandlerReturn<Params, State> {
    is<Scene extends AnyScene>(scene: Scene): this is InUnknownScene<Scene["~"]["params"], Scene["~"]["state"], Scene>;
}
interface PossibleInUnknownScene<Params, State extends StateTypesDefault, Scene extends AnyScene | null = null> extends EnterExit {
    current: Scene extends AnyScene ? InActiveSceneHandlerReturn<Scene["~"]["params"], Partial<Scene["~"]["state"]>> : InUnknownScene<Params, State, Scene> | undefined;
}

type ContextWithFrom = Pick<ContextType<Bot, "message" | "callback_query">, "from">;
declare function getInActiveSceneHandler<Params, State extends StateTypesDefault>(context: ContextWithFrom & {
    scene: InActiveSceneHandlerReturn<any, any>;
}, storage: Storage, sceneData: ScenesStorageData<Params, State>, scene: AnyScene, key: string, allowedScenes: string[]): InActiveSceneHandlerReturn<Params, State>;

type AnyScene = Scene<any, any, any, any>;
type StepHandler<T, Return = any> = (context: T, next: NextMiddleware) => any;
type SceneDerivesDefinitions<Params, State extends StateTypesDefault> = DeriveDefinitions & {
    global: {
        scene: ReturnType<typeof getInActiveSceneHandler<Params, State>>;
    };
};
declare class Scene<Params = never, Errors extends ErrorDefinitions = {}, State extends StateTypesDefault = Record<string, never>, Derives extends SceneDerivesDefinitions<Params, State> = SceneDerivesDefinitions<Params, State>> {
    /** @internal */
    "~": {
        params: Params;
        state: State;
        composer: Composer;
    };
    name: string;
    stepsCount: number;
    constructor(name: string);
    params<SceneParams>(): Scene<SceneParams, Errors, State, Modify<Derives, {
        global: {
            scene: Modify<Derives["global"]["scene"], {
                params: SceneParams;
            }>;
        };
    }>>;
    state<StateParams extends StateTypesDefault>(): Scene<Params, Errors, StateParams, Derives & {
        global: {
            scene: Modify<Derives["global"]["scene"], {
                state: StateParams;
            }>;
        };
    }>;
    /**
     * ! ** At the moment, it can only pick up types** */
    extend<NewPlugin extends AnyPlugin>(plugin: MaybePromise<NewPlugin>): Scene<Params, Errors & NewPlugin["_"]["Errors"], State, Derives & NewPlugin["_"]["Derives"]>;
    on<T extends UpdateName>(updateName: MaybeArray<T>, handler: Handler<ContextType<Bot, T> & Derives["global"] & Derives[T]>): this;
    use(handler: Handler<Context<Bot> & Derives["global"]>): this;
    step<T extends UpdateName, Handler extends StepHandler<ContextType<Bot, T> & Derives["global"] & Derives[T], any>, Return = Awaited<ReturnType<Handler>>>(updateName: MaybeArray<T>, handler: Handler): Scene<Params, Errors, Extract<Return, UpdateData<any>> extends UpdateData<infer Type> ? Record<string, never> extends State ? Type : State & Type : State, Modify<Derives, {
        global: Modify<Derives["global"], {
            scene: Modify<Derives["global"]["scene"], {
                state: Extract<Return, UpdateData<any>> extends UpdateData<infer Type> ? Record<string, never> extends State ? Type : State & Type : State;
            }>;
        }>;
    }>>;
    step(handler: Handler<Context<Bot> & Derives["global"]>): this;
    ask<Key extends string, Schema extends StandardSchemaV1, Return extends StateTypesDefault = {
        [key in Key]: StandardSchemaV1.InferOutput<Schema>;
    }>(key: Key, validator: Schema, firstTimeMessage: Stringable): Scene<Params, Errors, Record<string, never> extends State ? Return : State & Return, Modify<Derives, {
        global: Modify<Derives["global"], {
            scene: Modify<Derives["global"]["scene"], {
                state: Record<string, never> extends State ? Return : State & Return;
            }>;
        }>;
    }>>;
    compose(context: Context<Bot> & {
        [key: string]: unknown;
    }, onNext?: () => unknown): Promise<void>;
    run(context: Context<Bot> & {
        [key: string]: unknown;
    }, storage: Storage, key: string, data: ScenesStorageData<unknown, unknown>): Promise<void>;
}

interface ScenesDerivesOptions<WithCurrentScene extends boolean = false> extends ScenesOptions {
    withCurrentScene?: WithCurrentScene;
    scenes?: AnyScene[];
    /**
     * You should use the same storage for scenes and scenesDerives
     */
    storage: Storage;
}
declare function scenesDerives<WithCurrentScene extends boolean = false>(scenesOrOptions: AnyScene[] | ScenesDerivesOptions<WithCurrentScene>, optionsRaw?: ScenesDerivesOptions<WithCurrentScene>): Plugin<{}, gramio.DeriveDefinitions & {
    message: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    channel_post: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    inline_query: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    chosen_inline_result: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    callback_query: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    shipping_query: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    pre_checkout_query: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    chat_join_request: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    new_chat_members: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    new_chat_title: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    new_chat_photo: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    delete_chat_photo: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    group_chat_created: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    message_auto_delete_timer_changed: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    migrate_to_chat_id: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    migrate_from_chat_id: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    pinned_message: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    invoice: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    successful_payment: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    chat_shared: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    proximity_alert_triggered: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    video_chat_scheduled: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    video_chat_started: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    video_chat_ended: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    video_chat_participants_invited: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    web_app_data: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    location: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
    passport_data: {
        scene: WithCurrentScene extends true ? PossibleInUnknownScene<any, any> : EnterExit;
    };
}>;
declare function scenes(scenes: AnyScene[], options?: ScenesOptions): Plugin<{}, gramio.DeriveDefinitions & {
    message: {
        scene: Omit<EnterExit, "exit">;
    };
    callback_query: {
        scene: Omit<EnterExit, "exit">;
    };
}>;

export { Scene, scenes, scenesDerives };
export type { AnyScene, EnterExit, InActiveSceneHandlerReturn, InUnknownScene, Modify, PossibleInUnknownScene, SceneDerivesDefinitions, SceneEnterHandler, SceneStepReturn, SceneUpdateState, ScenesOptions, ScenesStorageData, StateTypesDefault, StepHandler, UpdateData };