@chainlink/cre-sdk 0.0.0 → 0.0.1-alpha

package/dist/generated-sdk/capabilities/blockchain/evm/v1alpha/client_sdk_gen.js

@@ -0,0 +1,489 @@
+import { create, fromBinary, fromJson, toBinary } from '@bufbuild/protobuf';
+import { AnySchema, EmptySchema } from '@bufbuild/protobuf/wkt';
+import { BalanceAtReplySchema, BalanceAtRequestSchema, CallContractReplySchema, CallContractRequestSchema, EstimateGasReplySchema, EstimateGasRequestSchema, FilterLogsReplySchema, FilterLogsRequestSchema, FilterLogTriggerRequestSchema, GetTransactionByHashReplySchema, GetTransactionByHashRequestSchema, GetTransactionReceiptReplySchema, GetTransactionReceiptRequestSchema, HeaderByNumberReplySchema, HeaderByNumberRequestSchema, LogSchema, RegisterLogTrackingRequestSchema, UnregisterLogTrackingRequestSchema, WriteReportReplySchema, WriteReportRequestSchema, } from '../../../../../generated/capabilities/blockchain/evm/v1alpha/client_pb';
+import { Mode } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+import { callCapability } from '../../../../../sdk/utils/capabilities/call-capability';
+import { CapabilityError } from '../../../../../sdk/utils/capabilities/capability-error';
+import {} from '../../../../../sdk/utils/triggers/trigger-interface';
+import { getTypeUrl } from '../../../../../sdk/utils/typeurl';
+/**
+ * Client Capability
+ *
+ * Capability ID: evm@1.0.0
+ * Default Mode: Mode.DON
+ * Capability Name: evm
+ * Capability Version: 1.0.0
+ */
+export class ClientCapability {
+    mode;
+    chainSelector;
+    /** The capability ID for this service */
+    static CAPABILITY_ID = 'evm@1.0.0';
+    /** The default execution mode for this capability */
+    static DEFAULT_MODE = Mode.DON;
+    static CAPABILITY_NAME = 'evm';
+    static CAPABILITY_VERSION = '1.0.0';
+    /** Available chain selectors */
+    static SUPPORTED_CHAINS = {
+        'avalanche-mainnet': 6433500567565415381n,
+        'avalanche-testnet-fuji': 14767482510784806043n,
+        'binance_smart_chain-mainnet-opbnb-1': 465944652040885897n,
+        'binance_smart_chain-testnet-opbnb-1': 13274425992935471758n,
+        'ethereum-mainnet': 5009297550715157269n,
+        'ethereum-mainnet-arbitrum-1': 4949039107694359620n,
+        'ethereum-mainnet-optimism-1': 3734403246176062136n,
+        'ethereum-testnet-sepolia': 16015286601757825753n,
+        'ethereum-testnet-sepolia-arbitrum-1': 3478487238524512106n,
+        'ethereum-testnet-sepolia-base-1': 10344971235874465080n,
+        'ethereum-testnet-sepolia-optimism-1': 5224473277236331295n,
+        'polygon-mainnet': 4051577828743386545n,
+        'polygon-testnet-amoy': 16281711391670634445n,
+    };
+    constructor(mode = ClientCapability.DEFAULT_MODE, chainSelector) {
+        this.mode = mode;
+        this.chainSelector = chainSelector;
+    }
+    callContract(input) {
+        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
+        const value = input.$typeName
+            ? input
+            : fromJson(CallContractRequestSchema, input);
+        const payload = {
+            typeUrl: getTypeUrl(CallContractRequestSchema),
+            value: toBinary(CallContractRequestSchema, value),
+        };
+        // Include chainSelector in capability ID for routing when specified
+        const capabilityId = this.chainSelector
+            ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
+            : ClientCapability.CAPABILITY_ID;
+        const capabilityResponse = callCapability({
+            capabilityId,
+            method: 'CallContract',
+            mode: this.mode,
+            payload,
+        });
+        return {
+            result: async () => {
+                const { response } = await capabilityResponse.result();
+                if (response.case === 'error') {
+                    throw new CapabilityError(response.value, {
+                        capabilityId,
+                        method: 'CallContract',
+                        mode: this.mode,
+                    });
+                }
+                if (response.case !== 'payload') {
+                    throw new CapabilityError('No payload in response', {
+                        capabilityId,
+                        method: 'CallContract',
+                        mode: this.mode,
+                    });
+                }
+                return fromBinary(CallContractReplySchema, response.value.value);
+            },
+        };
+    }
+    filterLogs(input) {
+        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
+        const value = input.$typeName
+            ? input
+            : fromJson(FilterLogsRequestSchema, input);
+        const payload = {
+            typeUrl: getTypeUrl(FilterLogsRequestSchema),
+            value: toBinary(FilterLogsRequestSchema, value),
+        };
+        // Include chainSelector in capability ID for routing when specified
+        const capabilityId = this.chainSelector
+            ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
+            : ClientCapability.CAPABILITY_ID;
+        const capabilityResponse = callCapability({
+            capabilityId,
+            method: 'FilterLogs',
+            mode: this.mode,
+            payload,
+        });
+        return {
+            result: async () => {
+                const { response } = await capabilityResponse.result();
+                if (response.case === 'error') {
+                    throw new CapabilityError(response.value, {
+                        capabilityId,
+                        method: 'FilterLogs',
+                        mode: this.mode,
+                    });
+                }
+                if (response.case !== 'payload') {
+                    throw new CapabilityError('No payload in response', {
+                        capabilityId,
+                        method: 'FilterLogs',
+                        mode: this.mode,
+                    });
+                }
+                return fromBinary(FilterLogsReplySchema, response.value.value);
+            },
+        };
+    }
+    balanceAt(input) {
+        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
+        const value = input.$typeName
+            ? input
+            : fromJson(BalanceAtRequestSchema, input);
+        const payload = {
+            typeUrl: getTypeUrl(BalanceAtRequestSchema),
+            value: toBinary(BalanceAtRequestSchema, value),
+        };
+        // Include chainSelector in capability ID for routing when specified
+        const capabilityId = this.chainSelector
+            ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
+            : ClientCapability.CAPABILITY_ID;
+        const capabilityResponse = callCapability({
+            capabilityId,
+            method: 'BalanceAt',
+            mode: this.mode,
+            payload,
+        });
+        return {
+            result: async () => {
+                const { response } = await capabilityResponse.result();
+                if (response.case === 'error') {
+                    throw new CapabilityError(response.value, {
+                        capabilityId,
+                        method: 'BalanceAt',
+                        mode: this.mode,
+                    });
+                }
+                if (response.case !== 'payload') {
+                    throw new CapabilityError('No payload in response', {
+                        capabilityId,
+                        method: 'BalanceAt',
+                        mode: this.mode,
+                    });
+                }
+                return fromBinary(BalanceAtReplySchema, response.value.value);
+            },
+        };
+    }
+    estimateGas(input) {
+        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
+        const value = input.$typeName
+            ? input
+            : fromJson(EstimateGasRequestSchema, input);
+        const payload = {
+            typeUrl: getTypeUrl(EstimateGasRequestSchema),
+            value: toBinary(EstimateGasRequestSchema, value),
+        };
+        // Include chainSelector in capability ID for routing when specified
+        const capabilityId = this.chainSelector
+            ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
+            : ClientCapability.CAPABILITY_ID;
+        const capabilityResponse = callCapability({
+            capabilityId,
+            method: 'EstimateGas',
+            mode: this.mode,
+            payload,
+        });
+        return {
+            result: async () => {
+                const { response } = await capabilityResponse.result();
+                if (response.case === 'error') {
+                    throw new CapabilityError(response.value, {
+                        capabilityId,
+                        method: 'EstimateGas',
+                        mode: this.mode,
+                    });
+                }
+                if (response.case !== 'payload') {
+                    throw new CapabilityError('No payload in response', {
+                        capabilityId,
+                        method: 'EstimateGas',
+                        mode: this.mode,
+                    });
+                }
+                return fromBinary(EstimateGasReplySchema, response.value.value);
+            },
+        };
+    }
+    getTransactionByHash(input) {
+        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
+        const value = input.$typeName
+            ? input
+            : fromJson(GetTransactionByHashRequestSchema, input);
+        const payload = {
+            typeUrl: getTypeUrl(GetTransactionByHashRequestSchema),
+            value: toBinary(GetTransactionByHashRequestSchema, value),
+        };
+        // Include chainSelector in capability ID for routing when specified
+        const capabilityId = this.chainSelector
+            ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
+            : ClientCapability.CAPABILITY_ID;
+        const capabilityResponse = callCapability({
+            capabilityId,
+            method: 'GetTransactionByHash',
+            mode: this.mode,
+            payload,
+        });
+        return {
+            result: async () => {
+                const { response } = await capabilityResponse.result();
+                if (response.case === 'error') {
+                    throw new CapabilityError(response.value, {
+                        capabilityId,
+                        method: 'GetTransactionByHash',
+                        mode: this.mode,
+                    });
+                }
+                if (response.case !== 'payload') {
+                    throw new CapabilityError('No payload in response', {
+                        capabilityId,
+                        method: 'GetTransactionByHash',
+                        mode: this.mode,
+                    });
+                }
+                return fromBinary(GetTransactionByHashReplySchema, response.value.value);
+            },
+        };
+    }
+    getTransactionReceipt(input) {
+        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
+        const value = input.$typeName
+            ? input
+            : fromJson(GetTransactionReceiptRequestSchema, input);
+        const payload = {
+            typeUrl: getTypeUrl(GetTransactionReceiptRequestSchema),
+            value: toBinary(GetTransactionReceiptRequestSchema, value),
+        };
+        // Include chainSelector in capability ID for routing when specified
+        const capabilityId = this.chainSelector
+            ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
+            : ClientCapability.CAPABILITY_ID;
+        const capabilityResponse = callCapability({
+            capabilityId,
+            method: 'GetTransactionReceipt',
+            mode: this.mode,
+            payload,
+        });
+        return {
+            result: async () => {
+                const { response } = await capabilityResponse.result();
+                if (response.case === 'error') {
+                    throw new CapabilityError(response.value, {
+                        capabilityId,
+                        method: 'GetTransactionReceipt',
+                        mode: this.mode,
+                    });
+                }
+                if (response.case !== 'payload') {
+                    throw new CapabilityError('No payload in response', {
+                        capabilityId,
+                        method: 'GetTransactionReceipt',
+                        mode: this.mode,
+                    });
+                }
+                return fromBinary(GetTransactionReceiptReplySchema, response.value.value);
+            },
+        };
+    }
+    headerByNumber(input) {
+        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
+        const value = input.$typeName
+            ? input
+            : fromJson(HeaderByNumberRequestSchema, input);
+        const payload = {
+            typeUrl: getTypeUrl(HeaderByNumberRequestSchema),
+            value: toBinary(HeaderByNumberRequestSchema, value),
+        };
+        // Include chainSelector in capability ID for routing when specified
+        const capabilityId = this.chainSelector
+            ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
+            : ClientCapability.CAPABILITY_ID;
+        const capabilityResponse = callCapability({
+            capabilityId,
+            method: 'HeaderByNumber',
+            mode: this.mode,
+            payload,
+        });
+        return {
+            result: async () => {
+                const { response } = await capabilityResponse.result();
+                if (response.case === 'error') {
+                    throw new CapabilityError(response.value, {
+                        capabilityId,
+                        method: 'HeaderByNumber',
+                        mode: this.mode,
+                    });
+                }
+                if (response.case !== 'payload') {
+                    throw new CapabilityError('No payload in response', {
+                        capabilityId,
+                        method: 'HeaderByNumber',
+                        mode: this.mode,
+                    });
+                }
+                return fromBinary(HeaderByNumberReplySchema, response.value.value);
+            },
+        };
+    }
+    registerLogTracking(input) {
+        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
+        const value = input.$typeName
+            ? input
+            : fromJson(RegisterLogTrackingRequestSchema, input);
+        const payload = {
+            typeUrl: getTypeUrl(RegisterLogTrackingRequestSchema),
+            value: toBinary(RegisterLogTrackingRequestSchema, value),
+        };
+        // Include chainSelector in capability ID for routing when specified
+        const capabilityId = this.chainSelector
+            ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
+            : ClientCapability.CAPABILITY_ID;
+        const capabilityResponse = callCapability({
+            capabilityId,
+            method: 'RegisterLogTracking',
+            mode: this.mode,
+            payload,
+        });
+        return {
+            result: async () => {
+                const { response } = await capabilityResponse.result();
+                if (response.case === 'error') {
+                    throw new CapabilityError(response.value, {
+                        capabilityId,
+                        method: 'RegisterLogTracking',
+                        mode: this.mode,
+                    });
+                }
+                if (response.case !== 'payload') {
+                    throw new CapabilityError('No payload in response', {
+                        capabilityId,
+                        method: 'RegisterLogTracking',
+                        mode: this.mode,
+                    });
+                }
+                return fromBinary(EmptySchema, response.value.value);
+            },
+        };
+    }
+    unregisterLogTracking(input) {
+        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
+        const value = input.$typeName
+            ? input
+            : fromJson(UnregisterLogTrackingRequestSchema, input);
+        const payload = {
+            typeUrl: getTypeUrl(UnregisterLogTrackingRequestSchema),
+            value: toBinary(UnregisterLogTrackingRequestSchema, value),
+        };
+        // Include chainSelector in capability ID for routing when specified
+        const capabilityId = this.chainSelector
+            ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
+            : ClientCapability.CAPABILITY_ID;
+        const capabilityResponse = callCapability({
+            capabilityId,
+            method: 'UnregisterLogTracking',
+            mode: this.mode,
+            payload,
+        });
+        return {
+            result: async () => {
+                const { response } = await capabilityResponse.result();
+                if (response.case === 'error') {
+                    throw new CapabilityError(response.value, {
+                        capabilityId,
+                        method: 'UnregisterLogTracking',
+                        mode: this.mode,
+                    });
+                }
+                if (response.case !== 'payload') {
+                    throw new CapabilityError('No payload in response', {
+                        capabilityId,
+                        method: 'UnregisterLogTracking',
+                        mode: this.mode,
+                    });
+                }
+                return fromBinary(EmptySchema, response.value.value);
+            },
+        };
+    }
+    logTrigger(config) {
+        return new ClientLogTrigger(this.mode, config, ClientCapability.CAPABILITY_ID, 'LogTrigger');
+    }
+    writeReport(input) {
+        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
+        const value = input.$typeName
+            ? input
+            : fromJson(WriteReportRequestSchema, input);
+        const payload = {
+            typeUrl: getTypeUrl(WriteReportRequestSchema),
+            value: toBinary(WriteReportRequestSchema, value),
+        };
+        // Include chainSelector in capability ID for routing when specified
+        const capabilityId = this.chainSelector
+            ? `${ClientCapability.CAPABILITY_NAME}:ChainSelector:${this.chainSelector}@${ClientCapability.CAPABILITY_VERSION}`
+            : ClientCapability.CAPABILITY_ID;
+        const capabilityResponse = callCapability({
+            capabilityId,
+            method: 'WriteReport',
+            mode: this.mode,
+            payload,
+        });
+        return {
+            result: async () => {
+                const { response } = await capabilityResponse.result();
+                if (response.case === 'error') {
+                    throw new CapabilityError(response.value, {
+                        capabilityId,
+                        method: 'WriteReport',
+                        mode: this.mode,
+                    });
+                }
+                if (response.case !== 'payload') {
+                    throw new CapabilityError('No payload in response', {
+                        capabilityId,
+                        method: 'WriteReport',
+                        mode: this.mode,
+                    });
+                }
+                return fromBinary(WriteReportReplySchema, response.value.value);
+            },
+        };
+    }
+}
+/**
+ * Trigger implementation for LogTrigger
+ */
+class ClientLogTrigger {
+    mode;
+    _capabilityId;
+    _method;
+    config;
+    constructor(mode, config, _capabilityId, _method) {
+        this.mode = mode;
+        this._capabilityId = _capabilityId;
+        this._method = _method;
+        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
+        this.config = config.$typeName
+            ? config
+            : fromJson(FilterLogTriggerRequestSchema, config);
+    }
+    capabilityId() {
+        return this._capabilityId;
+    }
+    method() {
+        return this._method;
+    }
+    outputSchema() {
+        return LogSchema;
+    }
+    configAsAny() {
+        return create(AnySchema, {
+            typeUrl: getTypeUrl(FilterLogTriggerRequestSchema),
+            value: toBinary(FilterLogTriggerRequestSchema, this.config),
+        });
+    }
+    /**
+     * Transform the raw trigger output - override this method if needed
+     * Default implementation returns the raw output unchanged
+     */
+    adapt(rawOutput) {
+        return rawOutput;
+    }
+}

package/dist/generated-sdk/capabilities/internal/actionandtrigger/v1/basic_sdk_gen.d.ts

@@ -0,0 +1,48 @@
+import { type Any } from '@bufbuild/protobuf/wkt';
+import { type Config, type ConfigJson, type Input, type InputJson, type Output, type TriggerEvent } from '../../../../../generated/capabilities/internal/actionandtrigger/v1/action_and_trigger_pb';
+import { Mode } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+import { type Trigger } from '../../../../../sdk/utils/triggers/trigger-interface';
+/**
+ * Basic Capability
+ *
+ * Capability ID: basic-test-action-trigger@1.0.0
+ * Default Mode: Mode.DON
+ * Capability Name: basic-test-action-trigger
+ * Capability Version: 1.0.0
+ */
+export declare class BasicCapability {
+    private readonly mode;
+    /** The capability ID for this service */
+    static readonly CAPABILITY_ID = "basic-test-action-trigger@1.0.0";
+    /** The default execution mode for this capability */
+    static readonly DEFAULT_MODE = Mode.DON;
+    static readonly CAPABILITY_NAME = "basic-test-action-trigger";
+    static readonly CAPABILITY_VERSION = "1.0.0";
+    constructor(mode?: Mode);
+    action(input: Input | InputJson): {
+        result: () => Promise<Output>;
+    };
+    trigger(config: ConfigJson): BasicTrigger;
+}
+/**
+ * Trigger implementation for Trigger
+ */
+declare class BasicTrigger implements Trigger<TriggerEvent, TriggerEvent> {
+    readonly mode: Mode;
+    private readonly _capabilityId;
+    private readonly _method;
+    readonly config: Config;
+    constructor(mode: Mode, config: Config | ConfigJson, _capabilityId: string, _method: string);
+    capabilityId(): string;
+    method(): string;
+    outputSchema(): import("@bufbuild/protobuf/codegenv2").GenMessage<TriggerEvent, {
+        jsonType: import("../../../../../generated/capabilities/internal/actionandtrigger/v1/action_and_trigger_pb").TriggerEventJson;
+    }>;
+    configAsAny(): Any;
+    /**
+     * Transform the raw trigger output - override this method if needed
+     * Default implementation returns the raw output unchanged
+     */
+    adapt(rawOutput: TriggerEvent): TriggerEvent;
+}
+export {};

package/dist/generated-sdk/capabilities/internal/actionandtrigger/v1/basic_sdk_gen.js

@@ -0,0 +1,108 @@
+import { create, fromBinary, fromJson, toBinary } from '@bufbuild/protobuf';
+import { AnySchema } from '@bufbuild/protobuf/wkt';
+import { ConfigSchema, InputSchema, OutputSchema, TriggerEventSchema, } from '../../../../../generated/capabilities/internal/actionandtrigger/v1/action_and_trigger_pb';
+import { Mode } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+import { callCapability } from '../../../../../sdk/utils/capabilities/call-capability';
+import { CapabilityError } from '../../../../../sdk/utils/capabilities/capability-error';
+import {} from '../../../../../sdk/utils/triggers/trigger-interface';
+import { getTypeUrl } from '../../../../../sdk/utils/typeurl';
+/**
+ * Basic Capability
+ *
+ * Capability ID: basic-test-action-trigger@1.0.0
+ * Default Mode: Mode.DON
+ * Capability Name: basic-test-action-trigger
+ * Capability Version: 1.0.0
+ */
+export class BasicCapability {
+    mode;
+    /** The capability ID for this service */
+    static CAPABILITY_ID = 'basic-test-action-trigger@1.0.0';
+    /** The default execution mode for this capability */
+    static DEFAULT_MODE = Mode.DON;
+    static CAPABILITY_NAME = 'basic-test-action-trigger';
+    static CAPABILITY_VERSION = '1.0.0';
+    constructor(mode = BasicCapability.DEFAULT_MODE) {
+        this.mode = mode;
+    }
+    action(input) {
+        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
+        const value = input.$typeName
+            ? input
+            : fromJson(InputSchema, input);
+        const payload = {
+            typeUrl: getTypeUrl(InputSchema),
+            value: toBinary(InputSchema, value),
+        };
+        const capabilityId = BasicCapability.CAPABILITY_ID;
+        const capabilityResponse = callCapability({
+            capabilityId,
+            method: 'Action',
+            mode: this.mode,
+            payload,
+        });
+        return {
+            result: async () => {
+                const { response } = await capabilityResponse.result();
+                if (response.case === 'error') {
+                    throw new CapabilityError(response.value, {
+                        capabilityId,
+                        method: 'Action',
+                        mode: this.mode,
+                    });
+                }
+                if (response.case !== 'payload') {
+                    throw new CapabilityError('No payload in response', {
+                        capabilityId,
+                        method: 'Action',
+                        mode: this.mode,
+                    });
+                }
+                return fromBinary(OutputSchema, response.value.value);
+            },
+        };
+    }
+    trigger(config) {
+        return new BasicTrigger(this.mode, config, BasicCapability.CAPABILITY_ID, 'Trigger');
+    }
+}
+/**
+ * Trigger implementation for Trigger
+ */
+class BasicTrigger {
+    mode;
+    _capabilityId;
+    _method;
+    config;
+    constructor(mode, config, _capabilityId, _method) {
+        this.mode = mode;
+        this._capabilityId = _capabilityId;
+        this._method = _method;
+        // biome-ignore lint/suspicious/noExplicitAny: Needed for runtime type checking of protocol buffer messages
+        this.config = config.$typeName
+            ? config
+            : fromJson(ConfigSchema, config);
+    }
+    capabilityId() {
+        return this._capabilityId;
+    }
+    method() {
+        return this._method;
+    }
+    outputSchema() {
+        return TriggerEventSchema;
+    }
+    configAsAny() {
+        return create(AnySchema, {
+            typeUrl: getTypeUrl(ConfigSchema),
+            value: toBinary(ConfigSchema, this.config),
+        });
+    }
+    /**
+     * Transform the raw trigger output - override this method if needed
+     * Default implementation returns the raw output unchanged
+     */
+    adapt(rawOutput) {
+        return rawOutput;
+    }
+}

package/dist/generated-sdk/capabilities/internal/basicaction/v1/basicaction_sdk_gen.d.ts

@@ -0,0 +1,23 @@
+import { type Inputs, type InputsJson, type Outputs } from '../../../../../generated/capabilities/internal/basicaction/v1/basic_action_pb';
+import { Mode } from '../../../../../generated/sdk/v1alpha/sdk_pb';
+/**
+ * BasicAction Capability
+ *
+ * Capability ID: basic-test-action@1.0.0
+ * Default Mode: Mode.DON
+ * Capability Name: basic-test-action
+ * Capability Version: 1.0.0
+ */
+export declare class BasicActionCapability {
+    private readonly mode;
+    /** The capability ID for this service */
+    static readonly CAPABILITY_ID = "basic-test-action@1.0.0";
+    /** The default execution mode for this capability */
+    static readonly DEFAULT_MODE = Mode.DON;
+    static readonly CAPABILITY_NAME = "basic-test-action";
+    static readonly CAPABILITY_VERSION = "1.0.0";
+    constructor(mode?: Mode);
+    performAction(input: Inputs | InputsJson): {
+        result: () => Promise<Outputs>;
+    };
+}