@salesforce/lds-adapters-platform-external-services 1.175.0 → 1.177.0

package/dist/es/es2018/platform-external-services.js

@@ -128,6 +128,395 @@ function createLink(ref) {
     };
 }
 
+const VERSION$a = "77afee4104970a3f44d1c478c16bd79c";
+function validate$d(obj, path = 'ExternalServiceActionParameterRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_description = obj.description;
+        const path_description = path + '.description';
+        if (typeof obj_description !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+        }
+        const obj_location = obj.location;
+        const path_location = path + '.location';
+        if (typeof obj_location !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_location + '" (at "' + path_location + '")');
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        const obj_required = obj.required;
+        const path_required = path + '.required';
+        if (typeof obj_required !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_required + '" (at "' + path_required + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$g = function ExternalServiceActionParameterRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$a,
+        private: [],
+        selections: [
+            {
+                name: 'description',
+                kind: 'Scalar'
+            },
+            {
+                name: 'location',
+                kind: 'Scalar'
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'required',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$a(existing, incoming) {
+    const existing_required = existing.required;
+    const incoming_required = incoming.required;
+    if (!(existing_required === incoming_required)) {
+        return false;
+    }
+    const existing_description = existing.description;
+    const incoming_description = incoming.description;
+    if (!(existing_description === incoming_description)) {
+        return false;
+    }
+    const existing_location = existing.location;
+    const incoming_location = incoming.location;
+    if (!(existing_location === incoming_location)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$9 = "4e90320a2a8521866935843772ace679";
+function validate$c(obj, path = 'ExternalServiceActionOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_externalServicePath = obj.externalServicePath;
+        const path_externalServicePath = path + '.externalServicePath';
+        if (typeof obj_externalServicePath !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_externalServicePath + '" (at "' + path_externalServicePath + '")');
+        }
+        const obj_method = obj.method;
+        const path_method = path + '.method';
+        if (typeof obj_method !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_method + '" (at "' + path_method + '")');
+        }
+        const obj_parameters = obj.parameters;
+        const path_parameters = path + '.parameters';
+        if (!ArrayIsArray(obj_parameters)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_parameters + '" (at "' + path_parameters + '")');
+        }
+        for (let i = 0; i < obj_parameters.length; i++) {
+            const obj_parameters_item = obj_parameters[i];
+            const path_parameters_item = path_parameters + '[' + i + ']';
+            const referencepath_parameters_itemValidationError = validate$d(obj_parameters_item, path_parameters_item);
+            if (referencepath_parameters_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ExternalServiceActionParameterRepresentation (at "' + path_parameters_item + '")\n';
+                message += referencepath_parameters_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_path = obj.path;
+        const path_path = path + '.path';
+        if (typeof obj_path !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_path + '" (at "' + path_path + '")');
+        }
+        const obj_registrationName = obj.registrationName;
+        const path_registrationName = path + '.registrationName';
+        if (typeof obj_registrationName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_registrationName + '" (at "' + path_registrationName + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$4 = 'ExternalServiceActionOutputRepresentation';
+function normalize$4(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$f = function ExternalServiceActionOutputRepresentationSelect() {
+    const { selections: ExternalServiceActionParameterRepresentation__selections, opaque: ExternalServiceActionParameterRepresentation__opaque, } = select$g();
+    return {
+        kind: 'Fragment',
+        version: VERSION$9,
+        private: [],
+        selections: [
+            {
+                name: 'externalServicePath',
+                kind: 'Scalar'
+            },
+            {
+                name: 'method',
+                kind: 'Scalar'
+            },
+            {
+                name: 'parameters',
+                kind: 'Object',
+                plural: true,
+                selections: ExternalServiceActionParameterRepresentation__selections
+            },
+            {
+                name: 'path',
+                kind: 'Scalar'
+            },
+            {
+                name: 'registrationName',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$9(existing, incoming) {
+    const existing_externalServicePath = existing.externalServicePath;
+    const incoming_externalServicePath = incoming.externalServicePath;
+    if (!(existing_externalServicePath === incoming_externalServicePath)) {
+        return false;
+    }
+    const existing_method = existing.method;
+    const incoming_method = incoming.method;
+    if (!(existing_method === incoming_method)) {
+        return false;
+    }
+    const existing_path = existing.path;
+    const incoming_path = incoming.path;
+    if (!(existing_path === incoming_path)) {
+        return false;
+    }
+    const existing_registrationName = existing.registrationName;
+    const incoming_registrationName = incoming.registrationName;
+    if (!(existing_registrationName === incoming_registrationName)) {
+        return false;
+    }
+    const existing_parameters = existing.parameters;
+    const incoming_parameters = incoming.parameters;
+    const equals_parameters_items = equalsArray(existing_parameters, incoming_parameters, (existing_parameters_item, incoming_parameters_item) => {
+        if (!(equals$a(existing_parameters_item, incoming_parameters_item))) {
+            return false;
+        }
+    });
+    if (equals_parameters_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest$4 = function ExternalServiceActionOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$c(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 300000;
+    let incomingRecord = normalize$4(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    if (existingRecord === undefined || equals$9(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    if (ttlToUse !== undefined) {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "external-services",
+            version: VERSION$9,
+            representationName: RepresentationType$4,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$4,
+        mergeable: false
+    });
+}
+
+function select$e(luvio, params) {
+    return select$f();
+}
+function keyBuilder$a(luvio, params) {
+    return keyPrefix + '::ExternalServiceActionOutputRepresentation:(' + 'actionName:' + params.urlParams.actionName + ')';
+}
+function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$4(storeKeyMap, luvio, response, () => keyBuilder$a(luvio, resourceParams));
+}
+function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$a(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$4, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$e(),
+        variables: {},
+    }, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function ingestError$4(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$a(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest$5(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v59.0',
+        basePath: '/externalservices/actions/services/' + config.urlParams.actionName + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getActionDetailsForService_ConfigPropertyNames = {
+    displayName: 'getActionDetailsForService',
+    parameters: {
+        required: ['actionName'],
+        optional: []
+    }
+};
+function createResourceParams$5(config) {
+    const resourceParams = {
+        urlParams: {
+            actionName: config.actionName
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$9(luvio, config) {
+    const resourceParams = createResourceParams$5(config);
+    return keyBuilder$a(luvio, resourceParams);
+}
+function typeCheckConfig$5(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_actionName = untrustedConfig.actionName;
+    if (typeof untrustedConfig_actionName === 'string') {
+        config.actionName = untrustedConfig_actionName;
+    }
+    return config;
+}
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$5(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$4(luvio, config) {
+    createResourceParams$5(config);
+    return select$e();
+}
+function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$4(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$5(luvio, config, options) {
+    const resourceParams = createResourceParams$5(config);
+    const request = createResourceRequest$5(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$4(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            luvioRequestMethod: undefined,
+        },
+        eventObservers
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority
+        };
+    }
+    return buildNetworkSnapshot$5(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$9(luvio, config),
+        node: adapterFragment$4(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getActionDetailsForServiceAdapterFactory = (luvio) => function externalServices__getActionDetailsForService(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$5(untrustedConfig, getActionDetailsForService_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
+};
+
 const VERSION$8 = "68601d043a553523b207d5fcc707e053";
 function validate$b(obj, path = 'InferenceErrorMessageRepresentation') {
     const v_error = (() => {
@@ -2252,4 +2641,4 @@ const getStatisticsForServiceAdapterFactory = (luvio) => function externalServic
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
 
-export { getDataShapeAdapterFactory, getOpenApiSpecAdapterFactory, getStatisticsAdapterFactory, getStatisticsForServiceAdapterFactory, validateSchemaAdapterFactory };
+export { getActionDetailsForServiceAdapterFactory, getDataShapeAdapterFactory, getOpenApiSpecAdapterFactory, getStatisticsAdapterFactory, getStatisticsForServiceAdapterFactory, validateSchemaAdapterFactory };

package/dist/es/es2018/types/src/generated/adapters/getActionDetailsForService.d.ts

@@ -0,0 +1,26 @@
+import { AdapterValidationConfig as adapter$45$utils_AdapterValidationConfig, Untrusted as adapter$45$utils_Untrusted } from './adapter-utils';
+import { ResourceRequestConfig as resources_getExternalservicesActionsServicesByActionName_ResourceRequestConfig } from '../resources/getExternalservicesActionsServicesByActionName';
+import { Luvio as $64$luvio_engine_Luvio, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Fragment as $64$luvio_engine_Fragment, Snapshot as $64$luvio_engine_Snapshot, FetchResponse as $64$luvio_engine_FetchResponse, ErrorResponse as $64$luvio_engine_ErrorResponse, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, CoercedAdapterRequestContext as $64$luvio_engine_CoercedAdapterRequestContext, StoreLookup as $64$luvio_engine_StoreLookup, AdapterFactory as $64$luvio_engine_AdapterFactory } from '@luvio/engine';
+import { ExternalServiceActionOutputRepresentation as types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation } from '../types/ExternalServiceActionOutputRepresentation';
+export declare const adapterName = "getActionDetailsForService";
+export declare const getActionDetailsForService_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
+export interface GetActionDetailsForServiceConfig {
+    actionName: string;
+}
+export declare function createResourceParams(config: GetActionDetailsForServiceConfig): resources_getExternalservicesActionsServicesByActionName_ResourceRequestConfig;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: GetActionDetailsForServiceConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: GetActionDetailsForServiceConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<GetActionDetailsForServiceConfig>): adapter$45$utils_Untrusted<GetActionDetailsForServiceConfig>;
+export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): GetActionDetailsForServiceConfig | null;
+export declare function adapterFragment(luvio: $64$luvio_engine_Luvio, config: GetActionDetailsForServiceConfig): $64$luvio_engine_Fragment;
+export declare function buildCachedSnapshot(luvio: $64$luvio_engine_Luvio, config: GetActionDetailsForServiceConfig): $64$luvio_engine_Snapshot<types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation, any>;
+export declare function onFetchResponseSuccess(luvio: $64$luvio_engine_Luvio, config: GetActionDetailsForServiceConfig, resourceParams: resources_getExternalservicesActionsServicesByActionName_ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation>): Promise<import("@luvio/engine").FulfilledSnapshot<types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation, any>>;
+export declare function onFetchResponseError(luvio: $64$luvio_engine_Luvio, config: GetActionDetailsForServiceConfig, resourceParams: resources_getExternalservicesActionsServicesByActionName_ResourceRequestConfig, response: $64$luvio_engine_ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: GetActionDetailsForServiceConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<$64$luvio_engine_Snapshot<types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation, any>>;
+export type BuildSnapshotContext = {
+    luvio: $64$luvio_engine_Luvio;
+    config: GetActionDetailsForServiceConfig;
+};
+export declare function buildNetworkSnapshotCachePolicy(context: BuildSnapshotContext, coercedAdapterRequestContext: $64$luvio_engine_CoercedAdapterRequestContext): Promise<$64$luvio_engine_Snapshot<types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation, any>>;
+export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: $64$luvio_engine_StoreLookup<types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation>): $64$luvio_engine_Snapshot<types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation, any>;
+export declare const getActionDetailsForServiceAdapterFactory: $64$luvio_engine_AdapterFactory<GetActionDetailsForServiceConfig, types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation>;

package/dist/es/es2018/types/src/generated/artifacts/main.d.ts

@@ -1,3 +1,4 @@
+export { getActionDetailsForServiceAdapterFactory } from '../adapters/getActionDetailsForService';
 export { getDataShapeAdapterFactory } from '../adapters/getDataShape';
 export { getOpenApiSpecAdapterFactory } from '../adapters/getOpenApiSpec';
 export { validateSchemaAdapterFactory } from '../adapters/validateSchema';

package/dist/es/es2018/types/src/generated/artifacts/sfdc.d.ts

@@ -1,10 +1,12 @@
+declare let getActionDetailsForService: any;
 declare let getDataShape: any;
 declare let getOpenApiSpec: any;
 declare let getStatistics: any;
 declare let getStatisticsForService: any;
 declare let validateSchema: any;
+declare let getActionDetailsForService_imperative: any;
 declare let getDataShape_imperative: any;
 declare let getOpenApiSpec_imperative: any;
 declare let getStatistics_imperative: any;
 declare let getStatisticsForService_imperative: any;
-export { getDataShape, getOpenApiSpec, getStatistics, getStatisticsForService, validateSchema, getDataShape_imperative, getOpenApiSpec_imperative, getStatistics_imperative, getStatisticsForService_imperative };
+export { getActionDetailsForService, getDataShape, getOpenApiSpec, getStatistics, getStatisticsForService, validateSchema, getActionDetailsForService_imperative, getDataShape_imperative, getOpenApiSpec_imperative, getStatistics_imperative, getStatisticsForService_imperative };

package/dist/es/es2018/types/src/generated/resources/getExternalservicesActionsServicesByActionName.d.ts

@@ -0,0 +1,15 @@
+import { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, FetchResponse as $64$luvio_engine_FetchResponse, SnapshotRefresh as $64$luvio_engine_SnapshotRefresh, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ErrorResponse as $64$luvio_engine_ErrorResponse, ErrorSnapshot as $64$luvio_engine_ErrorSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest } from '@luvio/engine';
+import { ExternalServiceActionOutputRepresentation as types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation } from '../types/ExternalServiceActionOutputRepresentation';
+export interface ResourceRequestConfig {
+    urlParams: {
+        actionName: string;
+    };
+}
+export declare function select(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_Fragment;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_NormalizedKeyMetadata;
+export declare function getResponseCacheKeys(storeKeyMap: any, luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation): void;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation>, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation, any>;
+export declare function ingestError(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig, error: $64$luvio_engine_ErrorResponse, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_ExternalServiceActionOutputRepresentation_ExternalServiceActionOutputRepresentation>): $64$luvio_engine_ErrorSnapshot;
+export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
+export default createResourceRequest;

package/dist/es/es2018/types/src/generated/types/ExternalServiceActionOutputRepresentation.d.ts

@@ -0,0 +1,41 @@
+import { ExternalServiceActionParameterRepresentation as ExternalServiceActionParameterRepresentation_ExternalServiceActionParameterRepresentation } from './ExternalServiceActionParameterRepresentation';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "4e90320a2a8521866935843772ace679";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ExternalServiceActionOutputRepresentation, existing: ExternalServiceActionOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ExternalServiceActionOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ExternalServiceActionOutputRepresentationNormalized, incoming: ExternalServiceActionOutputRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ExternalServiceActionOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Represents the Ext Service Action Details
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ExternalServiceActionOutputRepresentationNormalized {
+    /** The path for the external services edit page */
+    externalServicePath: string;
+    /** Http Method type of the service */
+    method: string;
+    /** Path/query parameters details of the service */
+    parameters: Array<ExternalServiceActionParameterRepresentation_ExternalServiceActionParameterRepresentation>;
+    /** Url Path used by the service */
+    path: string;
+    /** Registration name of the action service. */
+    registrationName: string;
+}
+/**
+ * Represents the Ext Service Action Details
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ExternalServiceActionOutputRepresentation {
+    externalServicePath: string;
+    method: string;
+    parameters: Array<ExternalServiceActionParameterRepresentation_ExternalServiceActionParameterRepresentation>;
+    path: string;
+    registrationName: string;
+}

package/dist/es/es2018/types/src/generated/types/ExternalServiceActionParameterRepresentation.d.ts

@@ -0,0 +1,37 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const VERSION = "77afee4104970a3f44d1c478c16bd79c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: ExternalServiceActionParameterRepresentation, existing: ExternalServiceActionParameterRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ExternalServiceActionParameterRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: ExternalServiceActionParameterRepresentationNormalized, incoming: ExternalServiceActionParameterRepresentationNormalized): boolean;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableStoreKeyMetadataMap, luvio: $64$luvio_engine_Luvio, input: ExternalServiceActionParameterRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): void;
+/**
+ * Input Parameter details of the external service
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ExternalServiceActionParameterRepresentationNormalized {
+    /** Description of the parameter */
+    description: string;
+    /** Type of Parameter i.e. Path/Query */
+    location: string;
+    /** Name of the Parameter */
+    name: string;
+    /** Is the parameter a required field */
+    required: boolean;
+}
+/**
+ * Input Parameter details of the external service
+ *
+ * Keys:
+ *    (none)
+ */
+export interface ExternalServiceActionParameterRepresentation {
+    description: string;
+    location: string;
+    name: string;
+    required: boolean;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-adapters-platform-external-services",
-    "version": "1.175.0",
+    "version": "1.177.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "External Services Connect API Family",
     "main": "dist/es/es2018/platform-external-services.js",

package/sfdc/index.js

@@ -138,6 +138,395 @@ function createLink(ref) {
     };
 }
 
+const VERSION$a = "77afee4104970a3f44d1c478c16bd79c";
+function validate$d(obj, path = 'ExternalServiceActionParameterRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_description = obj.description;
+        const path_description = path + '.description';
+        if (typeof obj_description !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_description + '" (at "' + path_description + '")');
+        }
+        const obj_location = obj.location;
+        const path_location = path + '.location';
+        if (typeof obj_location !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_location + '" (at "' + path_location + '")');
+        }
+        const obj_name = obj.name;
+        const path_name = path + '.name';
+        if (typeof obj_name !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_name + '" (at "' + path_name + '")');
+        }
+        const obj_required = obj.required;
+        const path_required = path + '.required';
+        if (typeof obj_required !== 'boolean') {
+            return new TypeError('Expected "boolean" but received "' + typeof obj_required + '" (at "' + path_required + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const select$g = function ExternalServiceActionParameterRepresentationSelect() {
+    return {
+        kind: 'Fragment',
+        version: VERSION$a,
+        private: [],
+        selections: [
+            {
+                name: 'description',
+                kind: 'Scalar'
+            },
+            {
+                name: 'location',
+                kind: 'Scalar'
+            },
+            {
+                name: 'name',
+                kind: 'Scalar'
+            },
+            {
+                name: 'required',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$a(existing, incoming) {
+    const existing_required = existing.required;
+    const incoming_required = incoming.required;
+    if (!(existing_required === incoming_required)) {
+        return false;
+    }
+    const existing_description = existing.description;
+    const incoming_description = incoming.description;
+    if (!(existing_description === incoming_description)) {
+        return false;
+    }
+    const existing_location = existing.location;
+    const incoming_location = incoming.location;
+    if (!(existing_location === incoming_location)) {
+        return false;
+    }
+    const existing_name = existing.name;
+    const incoming_name = incoming.name;
+    if (!(existing_name === incoming_name)) {
+        return false;
+    }
+    return true;
+}
+
+const VERSION$9 = "4e90320a2a8521866935843772ace679";
+function validate$c(obj, path = 'ExternalServiceActionOutputRepresentation') {
+    const v_error = (() => {
+        if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
+            return new TypeError('Expected "object" but received "' + typeof obj + '" (at "' + path + '")');
+        }
+        const obj_externalServicePath = obj.externalServicePath;
+        const path_externalServicePath = path + '.externalServicePath';
+        if (typeof obj_externalServicePath !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_externalServicePath + '" (at "' + path_externalServicePath + '")');
+        }
+        const obj_method = obj.method;
+        const path_method = path + '.method';
+        if (typeof obj_method !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_method + '" (at "' + path_method + '")');
+        }
+        const obj_parameters = obj.parameters;
+        const path_parameters = path + '.parameters';
+        if (!ArrayIsArray(obj_parameters)) {
+            return new TypeError('Expected "array" but received "' + typeof obj_parameters + '" (at "' + path_parameters + '")');
+        }
+        for (let i = 0; i < obj_parameters.length; i++) {
+            const obj_parameters_item = obj_parameters[i];
+            const path_parameters_item = path_parameters + '[' + i + ']';
+            const referencepath_parameters_itemValidationError = validate$d(obj_parameters_item, path_parameters_item);
+            if (referencepath_parameters_itemValidationError !== null) {
+                let message = 'Object doesn\'t match ExternalServiceActionParameterRepresentation (at "' + path_parameters_item + '")\n';
+                message += referencepath_parameters_itemValidationError.message.split('\n').map((line) => '\t' + line).join('\n');
+                return new TypeError(message);
+            }
+        }
+        const obj_path = obj.path;
+        const path_path = path + '.path';
+        if (typeof obj_path !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_path + '" (at "' + path_path + '")');
+        }
+        const obj_registrationName = obj.registrationName;
+        const path_registrationName = path + '.registrationName';
+        if (typeof obj_registrationName !== 'string') {
+            return new TypeError('Expected "string" but received "' + typeof obj_registrationName + '" (at "' + path_registrationName + '")');
+        }
+    })();
+    return v_error === undefined ? null : v_error;
+}
+const RepresentationType$4 = 'ExternalServiceActionOutputRepresentation';
+function normalize$4(input, existing, path, luvio, store, timestamp) {
+    return input;
+}
+const select$f = function ExternalServiceActionOutputRepresentationSelect() {
+    const { selections: ExternalServiceActionParameterRepresentation__selections, opaque: ExternalServiceActionParameterRepresentation__opaque, } = select$g();
+    return {
+        kind: 'Fragment',
+        version: VERSION$9,
+        private: [],
+        selections: [
+            {
+                name: 'externalServicePath',
+                kind: 'Scalar'
+            },
+            {
+                name: 'method',
+                kind: 'Scalar'
+            },
+            {
+                name: 'parameters',
+                kind: 'Object',
+                plural: true,
+                selections: ExternalServiceActionParameterRepresentation__selections
+            },
+            {
+                name: 'path',
+                kind: 'Scalar'
+            },
+            {
+                name: 'registrationName',
+                kind: 'Scalar'
+            }
+        ]
+    };
+};
+function equals$9(existing, incoming) {
+    const existing_externalServicePath = existing.externalServicePath;
+    const incoming_externalServicePath = incoming.externalServicePath;
+    if (!(existing_externalServicePath === incoming_externalServicePath)) {
+        return false;
+    }
+    const existing_method = existing.method;
+    const incoming_method = incoming.method;
+    if (!(existing_method === incoming_method)) {
+        return false;
+    }
+    const existing_path = existing.path;
+    const incoming_path = incoming.path;
+    if (!(existing_path === incoming_path)) {
+        return false;
+    }
+    const existing_registrationName = existing.registrationName;
+    const incoming_registrationName = incoming.registrationName;
+    if (!(existing_registrationName === incoming_registrationName)) {
+        return false;
+    }
+    const existing_parameters = existing.parameters;
+    const incoming_parameters = incoming.parameters;
+    const equals_parameters_items = equalsArray(existing_parameters, incoming_parameters, (existing_parameters_item, incoming_parameters_item) => {
+        if (!(equals$a(existing_parameters_item, incoming_parameters_item))) {
+            return false;
+        }
+    });
+    if (equals_parameters_items === false) {
+        return false;
+    }
+    return true;
+}
+const ingest$4 = function ExternalServiceActionOutputRepresentationIngest(input, path, luvio, store, timestamp) {
+    if (process.env.NODE_ENV !== 'production') {
+        const validateError = validate$c(input);
+        if (validateError !== null) {
+            throw validateError;
+        }
+    }
+    const key = path.fullPath;
+    const existingRecord = store.readEntry(key);
+    const ttlToUse = path.ttl !== undefined ? path.ttl : 300000;
+    let incomingRecord = normalize$4(input, store.readEntry(key), {
+        fullPath: key,
+        parent: path.parent,
+        propertyName: path.propertyName,
+        ttl: ttlToUse
+    });
+    if (existingRecord === undefined || equals$9(existingRecord, incomingRecord) === false) {
+        luvio.storePublish(key, incomingRecord);
+    }
+    if (ttlToUse !== undefined) {
+        const storeMetadataParams = {
+            ttl: ttlToUse,
+            namespace: "external-services",
+            version: VERSION$9,
+            representationName: RepresentationType$4,
+        };
+        luvio.publishStoreMetadata(key, storeMetadataParams);
+    }
+    return createLink(key);
+};
+function getTypeCacheKeys$4(rootKeySet, luvio, input, fullPathFactory) {
+    // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
+    const rootKey = fullPathFactory();
+    rootKeySet.set(rootKey, {
+        namespace: keyPrefix,
+        representationName: RepresentationType$4,
+        mergeable: false
+    });
+}
+
+function select$e(luvio, params) {
+    return select$f();
+}
+function keyBuilder$a(luvio, params) {
+    return keyPrefix + '::ExternalServiceActionOutputRepresentation:(' + 'actionName:' + params.urlParams.actionName + ')';
+}
+function getResponseCacheKeys$5(storeKeyMap, luvio, resourceParams, response) {
+    getTypeCacheKeys$4(storeKeyMap, luvio, response, () => keyBuilder$a(luvio, resourceParams));
+}
+function ingestSuccess$5(luvio, resourceParams, response, snapshotRefresh) {
+    const { body } = response;
+    const key = keyBuilder$a(luvio, resourceParams);
+    luvio.storeIngest(key, ingest$4, body);
+    const snapshot = luvio.storeLookup({
+        recordId: key,
+        node: select$e(),
+        variables: {},
+    }, snapshotRefresh);
+    if (process.env.NODE_ENV !== 'production') {
+        if (snapshot.state !== 'Fulfilled') {
+            throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+        }
+    }
+    deepFreeze(snapshot.data);
+    return snapshot;
+}
+function ingestError$4(luvio, params, error, snapshotRefresh) {
+    const key = keyBuilder$a(luvio, params);
+    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
+    luvio.storeIngestError(key, errorSnapshot);
+    return errorSnapshot;
+}
+function createResourceRequest$5(config) {
+    const headers = {};
+    return {
+        baseUri: '/services/data/v59.0',
+        basePath: '/externalservices/actions/services/' + config.urlParams.actionName + '',
+        method: 'get',
+        body: null,
+        urlParams: config.urlParams,
+        queryParams: {},
+        headers,
+        priority: 'normal',
+    };
+}
+
+const getActionDetailsForService_ConfigPropertyNames = {
+    displayName: 'getActionDetailsForService',
+    parameters: {
+        required: ['actionName'],
+        optional: []
+    }
+};
+function createResourceParams$5(config) {
+    const resourceParams = {
+        urlParams: {
+            actionName: config.actionName
+        }
+    };
+    return resourceParams;
+}
+function keyBuilder$9(luvio, config) {
+    const resourceParams = createResourceParams$5(config);
+    return keyBuilder$a(luvio, resourceParams);
+}
+function typeCheckConfig$5(untrustedConfig) {
+    const config = {};
+    const untrustedConfig_actionName = untrustedConfig.actionName;
+    if (typeof untrustedConfig_actionName === 'string') {
+        config.actionName = untrustedConfig_actionName;
+    }
+    return config;
+}
+function validateAdapterConfig$5(untrustedConfig, configPropertyNames) {
+    if (!untrustedIsObject(untrustedConfig)) {
+        return null;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        validateConfig(untrustedConfig, configPropertyNames);
+    }
+    const config = typeCheckConfig$5(untrustedConfig);
+    if (!areRequiredParametersPresent(config, configPropertyNames)) {
+        return null;
+    }
+    return config;
+}
+function adapterFragment$4(luvio, config) {
+    createResourceParams$5(config);
+    return select$e();
+}
+function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function onFetchResponseError$4(luvio, config, resourceParams, response) {
+    const snapshot = ingestError$4(luvio, resourceParams, response, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+    });
+    return luvio.storeBroadcast().then(() => snapshot);
+}
+function buildNetworkSnapshot$5(luvio, config, options) {
+    const resourceParams = createResourceParams$5(config);
+    const request = createResourceRequest$5(resourceParams);
+    return luvio.dispatchResourceRequest(request, options)
+        .then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess$4(luvio, config, resourceParams, response), () => {
+            const cache = new StoreKeyMap();
+            getResponseCacheKeys$5(cache, luvio, resourceParams, response.body);
+            return cache;
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$4(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            luvioRequestMethod: undefined,
+        },
+        eventObservers
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority
+        };
+    }
+    return buildNetworkSnapshot$5(luvio, config, dispatchOptions);
+}
+function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
+    const { luvio, config } = context;
+    const selector = {
+        recordId: keyBuilder$9(luvio, config),
+        node: adapterFragment$4(luvio, config),
+        variables: {},
+    };
+    const cacheSnapshot = storeLookup(selector, {
+        config,
+        resolve: () => buildNetworkSnapshot$5(luvio, config, snapshotRefreshOptions)
+    });
+    return cacheSnapshot;
+}
+const getActionDetailsForServiceAdapterFactory = (luvio) => function externalServices__getActionDetailsForService(untrustedConfig, requestContext) {
+    const config = validateAdapterConfig$5(untrustedConfig, getActionDetailsForService_ConfigPropertyNames);
+    // Invalid or incomplete config
+    if (config === null) {
+        return null;
+    }
+    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
+    buildCachedSnapshotCachePolicy$4, buildNetworkSnapshotCachePolicy$4);
+};
+
 const VERSION$8 = "68601d043a553523b207d5fcc707e053";
 function validate$b(obj, path = 'InferenceErrorMessageRepresentation') {
     const v_error = (() => {
@@ -2262,23 +2651,27 @@ const validateSchemaAdapterFactory = (luvio) => {
     };
 };
 
+let getActionDetailsForService;
 let getDataShape;
 let getOpenApiSpec;
 let getStatistics;
 let getStatisticsForService;
 let validateSchema;
 // Imperative GET Adapters
+let getActionDetailsForService_imperative;
 let getDataShape_imperative;
 let getOpenApiSpec_imperative;
 let getStatistics_imperative;
 let getStatisticsForService_imperative;
 // Adapter Metadata
+const getActionDetailsForServiceMetadata = { apiFamily: 'externalservices', name: 'getActionDetailsForService' };
 const getDataShapeMetadata = { apiFamily: 'externalservices', name: 'getDataShape' };
 const getOpenApiSpecMetadata = { apiFamily: 'externalservices', name: 'getOpenApiSpec', ttl: 500 };
 const getStatisticsMetadata = { apiFamily: 'externalservices', name: 'getStatistics' };
 const getStatisticsForServiceMetadata = { apiFamily: 'externalservices', name: 'getStatisticsForService' };
 function bindExportsTo(luvio) {
     // LDS Adapters
+    const getActionDetailsForService_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getActionDetailsForService', getActionDetailsForServiceAdapterFactory), getActionDetailsForServiceMetadata);
     const getDataShape_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getDataShape', getDataShapeAdapterFactory), getDataShapeMetadata);
     const getOpenApiSpec_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getOpenApiSpec', getOpenApiSpecAdapterFactory), getOpenApiSpecMetadata);
     const getStatistics_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getStatistics', getStatisticsAdapterFactory), getStatisticsMetadata);
@@ -2288,12 +2681,14 @@ function bindExportsTo(luvio) {
         return (config) => adapter(config).then(snapshot => snapshot.data);
     }
     return {
+        getActionDetailsForService: createWireAdapterConstructor(luvio, getActionDetailsForService_ldsAdapter, getActionDetailsForServiceMetadata),
         getDataShape: createWireAdapterConstructor(luvio, getDataShape_ldsAdapter, getDataShapeMetadata),
         getOpenApiSpec: createWireAdapterConstructor(luvio, getOpenApiSpec_ldsAdapter, getOpenApiSpecMetadata),
         getStatistics: createWireAdapterConstructor(luvio, getStatistics_ldsAdapter, getStatisticsMetadata),
         getStatisticsForService: createWireAdapterConstructor(luvio, getStatisticsForService_ldsAdapter, getStatisticsForServiceMetadata),
         validateSchema: unwrapSnapshotData(validateSchemaAdapterFactory),
         // Imperative GET Adapters
+        getActionDetailsForService_imperative: createImperativeAdapter(luvio, getActionDetailsForService_ldsAdapter, getActionDetailsForServiceMetadata),
         getDataShape_imperative: createImperativeAdapter(luvio, getDataShape_ldsAdapter, getDataShapeMetadata),
         getOpenApiSpec_imperative: createImperativeAdapter(luvio, getOpenApiSpec_ldsAdapter, getOpenApiSpecMetadata),
         getStatistics_imperative: createImperativeAdapter(luvio, getStatistics_ldsAdapter, getStatisticsMetadata),
@@ -2302,11 +2697,13 @@ function bindExportsTo(luvio) {
 }
 withDefaultLuvio((luvio) => {
     ({
+        getActionDetailsForService,
         getDataShape,
         getOpenApiSpec,
         getStatistics,
         getStatisticsForService,
         validateSchema,
+        getActionDetailsForService_imperative,
         getDataShape_imperative,
         getOpenApiSpec_imperative,
         getStatistics_imperative,
@@ -2314,5 +2711,5 @@ withDefaultLuvio((luvio) => {
     } = bindExportsTo(luvio));
 });
 
-export { getDataShape, getDataShape_imperative, getOpenApiSpec, getOpenApiSpec_imperative, getStatistics, getStatisticsForService, getStatisticsForService_imperative, getStatistics_imperative, validateSchema };
-// version: 1.175.0-a8d86b864
+export { getActionDetailsForService, getActionDetailsForService_imperative, getDataShape, getDataShape_imperative, getOpenApiSpec, getOpenApiSpec_imperative, getStatistics, getStatisticsForService, getStatisticsForService_imperative, getStatistics_imperative, validateSchema };
+// version: 1.177.0-56ff98dd2