scordi-extension 1.14.1

package/dist/blocks/ElementExistsBlock.d.ts

@@ -0,0 +1,45 @@
+import { Block, BlockResult } from './types';
+import z from 'zod';
+export interface ElementExistsBlock extends Block {
+    readonly name: 'element-exists';
+}
+export declare const ElementExistsBlockSchema: z.ZodObject<{
+    selector: z.ZodString;
+    findBy: z.ZodEnum<["cssSelector", "xpath"]>;
+    option: z.ZodObject<{
+        waitForSelector: z.ZodOptional<z.ZodBoolean>;
+        waitSelectorTimeout: z.ZodOptional<z.ZodNumber>;
+        multiple: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    }, {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    }>;
+} & {
+    name: z.ZodLiteral<"element-exists">;
+}, "strip", z.ZodTypeAny, {
+    name: "element-exists";
+    selector: string;
+    findBy: "cssSelector" | "xpath";
+    option: {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    };
+}, {
+    name: "element-exists";
+    selector: string;
+    findBy: "cssSelector" | "xpath";
+    option: {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    };
+}>;
+export declare function validateElementExistsBlock(data: unknown): ElementExistsBlock;
+export declare function handlerElementExists(data: ElementExistsBlock): Promise<BlockResult<boolean | null>>;
+//# sourceMappingURL=ElementExistsBlock.d.ts.map

package/dist/blocks/ElementExistsBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElementExistsBlock.d.ts","sourceRoot":"","sources":["../../src/blocks/ElementExistsBlock.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAmB,MAAM,SAAS,CAAC;AAC9D,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,MAAM,WAAW,kBAAmB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;CACjC;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEnC,CAAC;AAEH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,OAAO,GAAG,kBAAkB,CAE5E;AAED,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,WAAW,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC,CAmBtC"}

package/dist/blocks/EventClickBlock.d.ts

@@ -0,0 +1,67 @@
+import z from 'zod';
+import { Block, BlockResult } from './types';
+export interface EventClickBlock extends Block {
+    readonly name: 'event-click';
+    textFilter?: {
+        text: string | string[];
+        mode: 'exact' | 'contains' | 'startsWith' | 'endsWith' | 'regex';
+    };
+}
+export declare const EventClickBlockSchema: z.ZodObject<{
+    selector: z.ZodString;
+    findBy: z.ZodEnum<["cssSelector", "xpath"]>;
+    option: z.ZodObject<{
+        waitForSelector: z.ZodOptional<z.ZodBoolean>;
+        waitSelectorTimeout: z.ZodOptional<z.ZodNumber>;
+        multiple: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    }, {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    }>;
+} & {
+    name: z.ZodLiteral<"event-click">;
+    textFilter: z.ZodOptional<z.ZodObject<{
+        text: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+        mode: z.ZodEnum<["exact", "contains", "startsWith", "endsWith", "regex"]>;
+    }, "strip", z.ZodTypeAny, {
+        text: string | string[];
+        mode: "exact" | "regex" | "contains" | "startsWith" | "endsWith";
+    }, {
+        text: string | string[];
+        mode: "exact" | "regex" | "contains" | "startsWith" | "endsWith";
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: "event-click";
+    selector: string;
+    findBy: "cssSelector" | "xpath";
+    option: {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    };
+    textFilter?: {
+        text: string | string[];
+        mode: "exact" | "regex" | "contains" | "startsWith" | "endsWith";
+    } | undefined;
+}, {
+    name: "event-click";
+    selector: string;
+    findBy: "cssSelector" | "xpath";
+    option: {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    };
+    textFilter?: {
+        text: string | string[];
+        mode: "exact" | "regex" | "contains" | "startsWith" | "endsWith";
+    } | undefined;
+}>;
+export declare function validateEventClickBlock(data: unknown): EventClickBlock;
+export declare function handlerEventClick(data: EventClickBlock): Promise<BlockResult<boolean>>;
+//# sourceMappingURL=EventClickBlock.d.ts.map

package/dist/blocks/EventClickBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventClickBlock.d.ts","sourceRoot":"","sources":["../../src/blocks/EventClickBlock.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,EAAE,KAAK,EAAE,WAAW,EAAmB,MAAM,SAAS,CAAC;AAG9D,MAAM,WAAW,eAAgB,SAAQ,KAAK;IAC5C,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAE7B,UAAU,CAAC,EAAE;QACX,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;QACxB,IAAI,EAAE,OAAO,GAAG,UAAU,GAAG,YAAY,GAAG,UAAU,GAAG,OAAO,CAAC;KAClE,CAAC;CACH;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMhC,CAAC;AAEH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,GAAG,eAAe,CAEtE;AAED,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CA8C5F"}

package/dist/blocks/FetchApiBlock.d.ts

@@ -0,0 +1,49 @@
+import z from 'zod';
+import { Block, BlockResult } from './types';
+export interface FetchApiBlock extends Omit<Block, 'selector' | 'findBy' | 'option'> {
+    readonly name: 'fetch-api';
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    headers?: Record<string, string>;
+    body?: Record<string, any>;
+    timeout?: number;
+    parseJson?: boolean;
+    returnHeaders?: boolean;
+}
+export interface FetchApiResponse {
+    status: number;
+    statusText: string;
+    data: any;
+    headers?: Record<string, string>;
+}
+export declare const FetchApiBlockSchema: z.ZodObject<{
+    name: z.ZodLiteral<"fetch-api">;
+    url: z.ZodString;
+    method: z.ZodOptional<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    body: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    parseJson: z.ZodOptional<z.ZodBoolean>;
+    returnHeaders: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: "fetch-api";
+    url: string;
+    body?: Record<string, any> | undefined;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | undefined;
+    headers?: Record<string, string> | undefined;
+    timeout?: number | undefined;
+    parseJson?: boolean | undefined;
+    returnHeaders?: boolean | undefined;
+}, {
+    name: "fetch-api";
+    url: string;
+    body?: Record<string, any> | undefined;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | undefined;
+    headers?: Record<string, string> | undefined;
+    timeout?: number | undefined;
+    parseJson?: boolean | undefined;
+    returnHeaders?: boolean | undefined;
+}>;
+export declare function validateFetchApiBlock(data: unknown): FetchApiBlock;
+export declare function handlerFetchApi(data: FetchApiBlock): Promise<BlockResult<FetchApiResponse>>;
+//# sourceMappingURL=FetchApiBlock.d.ts.map

package/dist/blocks/FetchApiBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FetchApiBlock.d.ts","sourceRoot":"","sources":["../../src/blocks/FetchApiBlock.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE7C,MAAM,WAAW,aAAc,SAAQ,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAClF,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;IAC1E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,GAAG,CAAC;IACV,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS9B,CAAC;AAEH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,GAAG,aAAa,CAElE;AAED,wBAAsB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC,CAsCjG"}

package/dist/blocks/GetAttributeValueBlock.d.ts

@@ -0,0 +1,49 @@
+import z from 'zod';
+import { Block, BlockResult } from './types';
+export interface GetAttributeValueBlock extends Block {
+    readonly name: 'attribute-value';
+    attributeName: string;
+}
+export declare const GetAttributeValueBlockSchema: z.ZodObject<{
+    selector: z.ZodString;
+    findBy: z.ZodEnum<["cssSelector", "xpath"]>;
+    option: z.ZodObject<{
+        waitForSelector: z.ZodOptional<z.ZodBoolean>;
+        waitSelectorTimeout: z.ZodOptional<z.ZodNumber>;
+        multiple: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    }, {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    }>;
+} & {
+    name: z.ZodLiteral<"attribute-value">;
+    attributeName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: "attribute-value";
+    selector: string;
+    findBy: "cssSelector" | "xpath";
+    option: {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    };
+    attributeName: string;
+}, {
+    name: "attribute-value";
+    selector: string;
+    findBy: "cssSelector" | "xpath";
+    option: {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    };
+    attributeName: string;
+}>;
+export declare function validateGetAttributeValueBlock(data: unknown): GetAttributeValueBlock;
+export declare function handlerGetAttributeValue(data: GetAttributeValueBlock): Promise<BlockResult<string | string[] | null>>;
+//# sourceMappingURL=GetAttributeValueBlock.d.ts.map

package/dist/blocks/GetAttributeValueBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GetAttributeValueBlock.d.ts","sourceRoot":"","sources":["../../src/blocks/GetAttributeValueBlock.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,EAAE,KAAK,EAAE,WAAW,EAAmB,MAAM,SAAS,CAAC;AAG9D,MAAM,WAAW,sBAAuB,SAAQ,KAAK;IACnD,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvC,CAAC;AAEH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,OAAO,GAAG,sBAAsB,CAEpF;AAED,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,sBAAsB,GAC3B,OAAO,CAAC,WAAW,CAAC,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,CAgChD"}

package/dist/blocks/GetElementDataBlock.d.ts

@@ -0,0 +1,88 @@
+import z from 'zod';
+import { Block, BlockResult } from './types';
+export interface ElementData {
+    text?: string;
+    attributes?: Record<string, string | null>;
+    selector?: string;
+    xpath?: string;
+    [key: string]: any;
+}
+export interface GetElementDataBlock extends Block {
+    readonly name: 'get-element-data';
+    includeText?: boolean;
+    includeTags?: boolean;
+    useTextContent?: boolean;
+    regex?: string;
+    prefixText?: string;
+    suffixText?: string;
+    attributes?: string[];
+    includeSelector?: boolean;
+    includeXPath?: boolean;
+}
+export declare const GetElementDataBlockSchema: z.ZodObject<{
+    selector: z.ZodString;
+    findBy: z.ZodEnum<["cssSelector", "xpath"]>;
+    option: z.ZodObject<{
+        waitForSelector: z.ZodOptional<z.ZodBoolean>;
+        waitSelectorTimeout: z.ZodOptional<z.ZodNumber>;
+        multiple: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    }, {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    }>;
+} & {
+    name: z.ZodLiteral<"get-element-data">;
+    includeText: z.ZodOptional<z.ZodBoolean>;
+    includeTags: z.ZodOptional<z.ZodBoolean>;
+    useTextContent: z.ZodOptional<z.ZodBoolean>;
+    regex: z.ZodOptional<z.ZodString>;
+    prefixText: z.ZodOptional<z.ZodString>;
+    suffixText: z.ZodOptional<z.ZodString>;
+    attributes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    includeSelector: z.ZodOptional<z.ZodBoolean>;
+    includeXPath: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: "get-element-data";
+    selector: string;
+    findBy: "cssSelector" | "xpath";
+    option: {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    };
+    includeTags?: boolean | undefined;
+    useTextContent?: boolean | undefined;
+    regex?: string | undefined;
+    prefixText?: string | undefined;
+    suffixText?: string | undefined;
+    attributes?: string[] | undefined;
+    includeText?: boolean | undefined;
+    includeSelector?: boolean | undefined;
+    includeXPath?: boolean | undefined;
+}, {
+    name: "get-element-data";
+    selector: string;
+    findBy: "cssSelector" | "xpath";
+    option: {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    };
+    includeTags?: boolean | undefined;
+    useTextContent?: boolean | undefined;
+    regex?: string | undefined;
+    prefixText?: string | undefined;
+    suffixText?: string | undefined;
+    attributes?: string[] | undefined;
+    includeText?: boolean | undefined;
+    includeSelector?: boolean | undefined;
+    includeXPath?: boolean | undefined;
+}>;
+export declare function validateGetElementDataBlock(data: unknown): GetElementDataBlock;
+export declare function handlerGetElementData(data: GetElementDataBlock): Promise<BlockResult<ElementData | ElementData[]>>;
+//# sourceMappingURL=GetElementDataBlock.d.ts.map

package/dist/blocks/GetElementDataBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GetElementDataBlock.d.ts","sourceRoot":"","sources":["../../src/blocks/GetElementDataBlock.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,EAAE,KAAK,EAAE,WAAW,EAAmB,MAAM,SAAS,CAAC;AAK9D,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,mBAAoB,SAAQ,KAAK;IAChD,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAElC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IAEtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWpC,CAAC;AAEH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,OAAO,GAAG,mBAAmB,CAE9E;AAED,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAAC,WAAW,CAAC,WAAW,GAAG,WAAW,EAAE,CAAC,CAAC,CAyDnD"}

package/dist/blocks/GetTextBlock.d.ts

@@ -0,0 +1,85 @@
+import z from 'zod';
+import { Block, BlockResult } from './types';
+export interface GetTextBlock extends Block {
+    readonly name: 'get-text';
+    includeTags?: boolean;
+    useTextContent?: boolean;
+    regex?: string;
+    prefixText?: string;
+    suffixText?: string;
+    filterEmpty?: boolean;
+    scrollToCollect?: boolean;
+    scrollDistance?: number;
+    scrollWaitMs?: number;
+    maxScrollAttempts?: number;
+}
+export declare const GetTextBlockSchema: z.ZodObject<{
+    selector: z.ZodString;
+    findBy: z.ZodEnum<["cssSelector", "xpath"]>;
+    option: z.ZodObject<{
+        waitForSelector: z.ZodOptional<z.ZodBoolean>;
+        waitSelectorTimeout: z.ZodOptional<z.ZodNumber>;
+        multiple: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    }, {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    }>;
+} & {
+    name: z.ZodLiteral<"get-text">;
+    includeTags: z.ZodOptional<z.ZodBoolean>;
+    useTextContent: z.ZodOptional<z.ZodBoolean>;
+    regex: z.ZodOptional<z.ZodString>;
+    prefixText: z.ZodOptional<z.ZodString>;
+    suffixText: z.ZodOptional<z.ZodString>;
+    filterEmpty: z.ZodOptional<z.ZodBoolean>;
+    scrollToCollect: z.ZodOptional<z.ZodBoolean>;
+    scrollDistance: z.ZodOptional<z.ZodNumber>;
+    scrollWaitMs: z.ZodOptional<z.ZodNumber>;
+    maxScrollAttempts: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: "get-text";
+    selector: string;
+    findBy: "cssSelector" | "xpath";
+    option: {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    };
+    includeTags?: boolean | undefined;
+    useTextContent?: boolean | undefined;
+    regex?: string | undefined;
+    prefixText?: string | undefined;
+    suffixText?: string | undefined;
+    filterEmpty?: boolean | undefined;
+    scrollToCollect?: boolean | undefined;
+    scrollDistance?: number | undefined;
+    scrollWaitMs?: number | undefined;
+    maxScrollAttempts?: number | undefined;
+}, {
+    name: "get-text";
+    selector: string;
+    findBy: "cssSelector" | "xpath";
+    option: {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    };
+    includeTags?: boolean | undefined;
+    useTextContent?: boolean | undefined;
+    regex?: string | undefined;
+    prefixText?: string | undefined;
+    suffixText?: string | undefined;
+    filterEmpty?: boolean | undefined;
+    scrollToCollect?: boolean | undefined;
+    scrollDistance?: number | undefined;
+    scrollWaitMs?: number | undefined;
+    maxScrollAttempts?: number | undefined;
+}>;
+export declare function validateGetTextBlock(data: unknown): GetTextBlock;
+export declare function handlerGetText(data: GetTextBlock): Promise<BlockResult<string | string[]>>;
+//# sourceMappingURL=GetTextBlock.d.ts.map

package/dist/blocks/GetTextBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GetTextBlock.d.ts","sourceRoot":"","sources":["../../src/blocks/GetTextBlock.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,EAAE,KAAK,EAAE,WAAW,EAAmB,MAAM,SAAS,CAAC;AAG9D,MAAM,WAAW,YAAa,SAAQ,KAAK;IACzC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY7B,CAAC;AAEH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,YAAY,CAEhE;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC,CAqEhG"}

package/dist/blocks/GetValueFormBlock.d.ts

@@ -0,0 +1,49 @@
+import { Block, BlockResult } from './types';
+import z from 'zod';
+export interface GetValueFormsBlock extends Block {
+    readonly name: 'get-value-form';
+    type?: 'text-field' | 'select' | 'checkbox';
+}
+export declare const GetValueFormsBlockSchema: z.ZodObject<{
+    selector: z.ZodString;
+    findBy: z.ZodEnum<["cssSelector", "xpath"]>;
+    option: z.ZodObject<{
+        waitForSelector: z.ZodOptional<z.ZodBoolean>;
+        waitSelectorTimeout: z.ZodOptional<z.ZodNumber>;
+        multiple: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    }, {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    }>;
+} & {
+    name: z.ZodLiteral<"get-value-form">;
+    type: z.ZodOptional<z.ZodEnum<["text-field", "select", "checkbox"]>>;
+}, "strip", z.ZodTypeAny, {
+    name: "get-value-form";
+    selector: string;
+    findBy: "cssSelector" | "xpath";
+    option: {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    };
+    type?: "select" | "text-field" | "checkbox" | undefined;
+}, {
+    name: "get-value-form";
+    selector: string;
+    findBy: "cssSelector" | "xpath";
+    option: {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    };
+    type?: "select" | "text-field" | "checkbox" | undefined;
+}>;
+export declare function validateGetValueFormsBlock(data: unknown): GetValueFormsBlock;
+export declare function handlerGetValueForm(data: GetValueFormsBlock): Promise<BlockResult<string | boolean | null>>;
+//# sourceMappingURL=GetValueFormBlock.d.ts.map

package/dist/blocks/GetValueFormBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GetValueFormBlock.d.ts","sourceRoot":"","sources":["../../src/blocks/GetValueFormBlock.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAmB,MAAM,SAAS,CAAC;AAC9D,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,MAAM,WAAW,kBAAmB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,IAAI,CAAC,EAAE,YAAY,GAAG,QAAQ,GAAG,UAAU,CAAC;CAC7C;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGnC,CAAC;AAEH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,OAAO,GAAG,kBAAkB,CAE5E;AAED,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,WAAW,CAAC,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,CAAC,CAuB/C"}

package/dist/blocks/KeypressBlock.d.ts

@@ -0,0 +1,31 @@
+import z from 'zod';
+import { Block, BlockResult } from './types';
+export interface KeypressBlock extends Omit<Block, 'selector' | 'findBy' | 'option'> {
+    readonly name: 'keypress';
+    key: string;
+    code?: string;
+    keyCode?: number;
+    modifiers?: ('Alt' | 'Control' | 'Meta' | 'Shift')[];
+}
+export declare const KeypressBlockSchema: z.ZodObject<{
+    name: z.ZodLiteral<"keypress">;
+    key: z.ZodString;
+    code: z.ZodOptional<z.ZodString>;
+    keyCode: z.ZodOptional<z.ZodNumber>;
+    modifiers: z.ZodOptional<z.ZodArray<z.ZodEnum<["Alt", "Control", "Meta", "Shift"]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: "keypress";
+    key: string;
+    code?: string | undefined;
+    keyCode?: number | undefined;
+    modifiers?: ("Alt" | "Control" | "Meta" | "Shift")[] | undefined;
+}, {
+    name: "keypress";
+    key: string;
+    code?: string | undefined;
+    keyCode?: number | undefined;
+    modifiers?: ("Alt" | "Control" | "Meta" | "Shift")[] | undefined;
+}>;
+export declare function validateKeypressBlock(data: unknown): KeypressBlock;
+export declare function handlerKeypress(data: KeypressBlock): Promise<BlockResult<boolean>>;
+//# sourceMappingURL=KeypressBlock.d.ts.map

package/dist/blocks/KeypressBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeypressBlock.d.ts","sourceRoot":"","sources":["../../src/blocks/KeypressBlock.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE7C,MAAM,WAAW,aAAe,SAAQ,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACnF,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,CAAC,KAAK,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC;CACtD;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;EAM9B,CAAC;AAEH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,GAAG,aAAa,CAElE;AAED,wBAAsB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAexF"}

package/dist/blocks/SaveAssetsBlock.d.ts

@@ -0,0 +1,45 @@
+import { Block, BlockResult } from './types';
+import z from 'zod';
+export interface SaveAssetsBlock extends Block {
+    readonly name: 'save-assets';
+}
+export declare const SaveAssetsBlockSchema: z.ZodObject<{
+    selector: z.ZodString;
+    findBy: z.ZodEnum<["cssSelector", "xpath"]>;
+    option: z.ZodObject<{
+        waitForSelector: z.ZodOptional<z.ZodBoolean>;
+        waitSelectorTimeout: z.ZodOptional<z.ZodNumber>;
+        multiple: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    }, {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    }>;
+} & {
+    name: z.ZodLiteral<"save-assets">;
+}, "strip", z.ZodTypeAny, {
+    name: "save-assets";
+    selector: string;
+    findBy: "cssSelector" | "xpath";
+    option: {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    };
+}, {
+    name: "save-assets";
+    selector: string;
+    findBy: "cssSelector" | "xpath";
+    option: {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    };
+}>;
+export declare function validateSaveAssetsBlock(data: unknown): SaveAssetsBlock;
+export declare function handlerSaveAssets(data: SaveAssetsBlock): Promise<BlockResult<string[] | null>>;
+//# sourceMappingURL=SaveAssetsBlock.d.ts.map

package/dist/blocks/SaveAssetsBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SaveAssetsBlock.d.ts","sourceRoot":"","sources":["../../src/blocks/SaveAssetsBlock.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAmB,MAAM,SAAS,CAAC;AAC9D,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,MAAM,WAAW,eAAgB,SAAQ,KAAK;IAC5C,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;CAC9B;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEhC,CAAC;AAEH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,GAAG,eAAe,CAEtE;AAED,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,CAqCvC"}

package/dist/blocks/ScrollBlock.d.ts

@@ -0,0 +1,65 @@
+import z from 'zod';
+import { Block, BlockResult } from './types';
+export interface ScrollBlock extends Block {
+    readonly name: 'scroll';
+    scrollType?: 'toElement' | 'toBottom' | 'byDistance' | 'untilLoaded';
+    distance?: number;
+    behavior?: 'auto' | 'smooth';
+    maxScrolls?: number;
+    waitAfterScroll?: number;
+}
+export declare const ScrollBlockSchema: z.ZodObject<{
+    selector: z.ZodString;
+    findBy: z.ZodEnum<["cssSelector", "xpath"]>;
+    option: z.ZodObject<{
+        waitForSelector: z.ZodOptional<z.ZodBoolean>;
+        waitSelectorTimeout: z.ZodOptional<z.ZodNumber>;
+        multiple: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    }, {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    }>;
+} & {
+    name: z.ZodLiteral<"scroll">;
+    scrollType: z.ZodOptional<z.ZodEnum<["toElement", "toBottom", "byDistance", "untilLoaded"]>>;
+    distance: z.ZodOptional<z.ZodNumber>;
+    behavior: z.ZodOptional<z.ZodEnum<["auto", "smooth"]>>;
+    maxScrolls: z.ZodOptional<z.ZodNumber>;
+    waitAfterScroll: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: "scroll";
+    selector: string;
+    findBy: "cssSelector" | "xpath";
+    option: {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    };
+    behavior?: "auto" | "smooth" | undefined;
+    scrollType?: "toElement" | "toBottom" | "byDistance" | "untilLoaded" | undefined;
+    distance?: number | undefined;
+    maxScrolls?: number | undefined;
+    waitAfterScroll?: number | undefined;
+}, {
+    name: "scroll";
+    selector: string;
+    findBy: "cssSelector" | "xpath";
+    option: {
+        waitForSelector?: boolean | undefined;
+        waitSelectorTimeout?: number | undefined;
+        multiple?: boolean | undefined;
+    };
+    behavior?: "auto" | "smooth" | undefined;
+    scrollType?: "toElement" | "toBottom" | "byDistance" | "untilLoaded" | undefined;
+    distance?: number | undefined;
+    maxScrolls?: number | undefined;
+    waitAfterScroll?: number | undefined;
+}>;
+export declare function validateScrollBlock(data: unknown): ScrollBlock;
+export declare function handlerScroll(data: ScrollBlock): Promise<BlockResult<boolean>>;
+//# sourceMappingURL=ScrollBlock.d.ts.map

package/dist/blocks/ScrollBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScrollBlock.d.ts","sourceRoot":"","sources":["../../src/blocks/ScrollBlock.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,EAAE,KAAK,EAAE,WAAW,EAAmB,MAAM,SAAS,CAAC;AAG9D,MAAM,WAAW,WAAY,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,UAAU,CAAC,EAAE,WAAW,GAAG,UAAU,GAAG,YAAY,GAAG,aAAa,CAAC;IACrE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO5B,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,WAAW,CAE9D;AAED,wBAAsB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAuCpF"}