Make

Get App Module

Retrieves a single Module from the given App in the given Organization.

RequiredorganizationIdappNameappVersionmoduleName

List App Modules

Retrieves a list of Modules available for the given App in the given Organization and Team.

RequiredorganizationIdappNameappVersion

Get App Documentation

Retrieves markdown documentation for the specific Make App. Use when configuring Make Apps and Modules and when you need to learn more about the available capabilities.

RequiredappName

List Apps

Retrieves a list of Apps available for Scenario Building in the given Organization and Team.

RequiredorganizationIdteamId

Get Recommended Apps

Based on the user's intention, recommend applications that can assist in achieving their goals. This tool should provide a list of applications that are relevant to the user's needs, including their names and versions.

Requiredintention

Get Connection Metadata

Retrieves metadata of the given connection, or returns an error when the connection type doesn't exist.

RequiredtypeName

Get connection

Get connection (connections): Get details of a specific connection.

RequiredconnectionId

List connections

List connections (connections): List connections for a team.

RequiredteamId

Create credential request

Create credential request (credential-requests): Create a credential request for the currently authenticated user to set up connections and keys. This will return a URL where the user can authorize the credentials, so that they can be used in scenarios.

RequiredteamIdcredentials

Create credential request by connection/key types

Create credential request by connection/key types (credential-requests): Create a credential request for one or more connections (OAuth) and/or keys (API keys) by their type identifiers (e.g. "google", "slack", "apikeyauth"). Use this when you know the exact connection or key types needed. The response includes the created request, an array of credentials associated with the request, and a publicUri where the end-user must go to authorize the requested credentials. At least one connection or one key must be provided.

RequiredteamId

Decline credential

Decline credential (credential-requests): Decline a credential authorization request by ID, setting its status to "declined" and preventing it from being authorized. An optional reason can be provided to explain the decision. This operation is idempotent - declining an already-declined credential has no additional effect.

RequiredcredentialId

Delete credential

Delete credential (credential-requests): Delete a credential (e.g., revoke OAuth tokens or remove stored API keys) and reset its state to pending. Use this when a credential needs re-authorization with updated permissions, tokens have become stale, or you want to force re-authentication. After deletion, the credential can be authorized again through the normal flow.

RequiredcredentialId

Delete credential request

Delete credential request (credential-requests): Permanently delete a credential request and all associated credentials (connections and API keys) by ID. Any scenarios using connections from this request will lose access to the corresponding services. This action cannot be undone.

RequiredrequestId

Extend connection OAuth scopes

Extend connection OAuth scopes (credential-requests): Add new OAuth scopes to an existing connection. Use this when a connection exists but lacks the permissions (scopes) needed for a specific operation. Creates a credential request that the end-user must authorize via the returned publicUri to grant the additional scopes. Fails if all requested scopes are already present on the connection — that error means the connection already satisfies the requirement: treat it as success and use the connection as-is; do not retry.

RequiredconnectionIdscopes

Get credential request details

Get credential request details (credential-requests): Retrieve detailed information about a specific credential request by its ID. Returns all associated credentials with their authorization status, provider configuration, user details, and authorization URLs for pending credentials. Use this to check the state of credentials within a request.

RequiredrequestId

List credential requests

List credential requests (credential-requests): Retrieve a list of credential requests. Each request can contain multiple credentials (connections and API keys). Filter by team, user, provider, status, or name to find specific requests.

RequiredteamId

List app modules with credentials

List app modules with credentials (credential-requests): List all modules of a given Make app (and version) that require credentials, along with the required credential type and OAuth scopes. Use this to discover which modules exist for an app before constructing a credential request — the returned `id` values are what you pass in `credentials[].appModules` for `credential-requests_create`. For custom/SDK apps, prefix the app name with `app#` (e.g. `app#my-custom-app`).

RequiredappNameappVersion

Create custom property structure item

Create custom property structure item (custom-property-structure-items): Create an item (field definition) in a custom property structure. The item's name and type cannot be changed after creation. `options` is required for the 'dropdown' and 'multiselect' types and not allowed for any other type.

RequiredcustomPropertyStructureIdnamelabeltyperequired

Delete custom property structure item

Delete custom property structure item (custom-property-structure-items): Delete a custom property structure item. Deleting an item also deletes any scenario data filled in for it — this is irreversible. If scenarios already have data for the item, the call fails with IM004 unless 'confirmed' is true.

RequiredcustomPropertyStructureItemId

List custom property structure items

List custom property structure items (custom-property-structure-items): List the items (field definitions) of a custom property structure. Use custom-property-structures_list to find the structure ID.

RequiredcustomPropertyStructureId

Update custom property structure item

Update custom property structure item (custom-property-structure-items): Update a custom property structure item. The item's name and type cannot be changed. When updating `options` of a 'dropdown'/'multiselect' item, the new set fully replaces the current one — existing scenario data referencing removed options is not remapped.

RequiredcustomPropertyStructureItemId

Create custom property structure

Create custom property structure (custom-property-structures): Create a custom property structure for an organization. Only one structure can exist per (associatedType, belongerType, belongerId) combination — creating a second one for the same organization fails with IM005. Once created, a structure cannot be deleted through the API. Use 'scenario' as associatedType and 'organization' as belongerType — these are the only values the API currently accepts.

RequiredassociatedTypebelongerTypebelongerId

List custom property structures

List custom property structures (custom-property-structures): List the custom property structures defined for an organization. Requires the organization's custom-properties feature to be enabled (error IM027 otherwise). At most one structure can exist per combination of associated type, belonger type, and belonger ID — currently 'scenario'/'organization' is the only supported combination — and structures cannot be deleted through the API.

RequiredorganizationId

Create data store record

Create data store record (data-store-records): Create a new record in a data store.

RequireddataStoreIddata

Delete data store records

Delete data store records (data-store-records): Delete specific records from a data store by keys.

RequireddataStoreIdkeys

List data store records

List data store records (data-store-records): List all records in a data store.

RequireddataStoreId

Replace data store record

Replace data store record (data-store-records): Replace an existing record in a data store or create if it doesn't exist.

RequireddataStoreIdkeydata

Update data store record

Update data store record (data-store-records): Update an existing record in a data store.

RequireddataStoreIdkeydata

Create data store

Create data store (data-stores): Create a new data store.

RequirednameteamIdmaxSizeMB

Delete data store

Delete data store (data-stores): Delete a data store.

RequireddataStoreId

Get data store

Get data store (data-stores): Get data store details by ID.

RequireddataStoreId

List data stores

List data stores (data-stores): List all data stores for a team.

RequiredteamId

Update data store

Update data store (data-stores): Update a data store.

RequireddataStoreId

Create data structure

Create data structure (data-structures): Create a new data structure.

RequiredteamIdnamestrictspec

Delete data structure

Delete data structure (data-structures): Delete a data structure.

RequireddataStructureId

Generate Data Structure Definition

Generates Data Structure Definition in Make Parameters Format from the sample data provided as input.

Requireddata

Get data structure

Get data structure (data-structures): Get details of a specific data structure.

RequireddataStructureId

List data structures

List data structures (data-structures): List data structures for a team.

RequiredteamId

Update data structure

Update data structure (data-structures): Update an existing data structure.

RequireddataStructureId

List countries

List countries (enums): List all available countries.

List regions

List regions (enums): List all available regions.

List timezones

List timezones (enums): List all available timezones.

Get environment

Lists the Make zone, organizations, and teams reachable through this connection, including private spaces. Most Make resources belong to a team; other tools require the organizationId and teamId returned here. Call this first when you need ids. A private space id is valid wherever a teamId is accepted.

Get execution

Get execution (executions): Get execution metadata only: status, duration, operations consumed and error class — NOT per-module inputs/outputs. To see what each module did or why a run failed, use executions_get-detail instead.

RequiredscenarioIdexecutionId

Get execution detail

Get execution detail (executions): Get the full per-module detail of an execution: the inputs and outputs of each module, the failing module and its error. ALWAYS call this after a failed or suspicious run BEFORE retrying or editing the scenario. For lightweight status/duration metadata only, use executions_get instead.

RequiredscenarioIdexecutionId

List executions

List executions (executions): List executions for a scenario.

RequiredscenarioId

Extract Components from Blueprint

This tool analyzes a given Blueprint and extracts a list of various Connections, Keys, Hooks and other components that are required to be provided in order to map the Blueprint properly. Use this tool to identify all necessary components to collect before creating a new Make Scenario based on the Blueprint. The output will help in preparing the Scenario by ensuring all required resources are available.

RequiredorganizationIdteamIdblueprint

Extract Components from Module

Extracts the list of Components required by the particular Module. Use to identify what Connections, Keys, Hooks and other resources are needed to work with the Module.

RequiredorganizationIdteamIdappNameappVersionmoduleName

Create folder

Create folder (folders): Create a new folder.

RequiredteamIdname

Delete folder

Delete folder (folders): Delete a folder.

RequiredfolderId

List folders

List folders (folders): List scenario folders for a team. If you do not know the teamId, find it via organizations_list (each organization lists its teams) or teams_list, or ask the user — never guess IDs.

RequiredteamId

Update folder

Update folder (folders): Update an existing folder.

RequiredfolderId

Get Hook Configuration

Retrieves the manifest and form configuration of a hook TYPE (not a hook instance — use hooks_get for that). Use this to understand what fields are required when configuring a hook, e.g. before hooks_create.

RequiredtypeName

Delete webhook queue items

Delete webhook queue items (hook-incomings): Delete items from a webhook's processing queue. Specify `ids` to delete specific items, or `all: true` (with `confirmed: true`) to clear the entire queue. An item currently being processed cannot be deleted.

RequiredhookId

Get webhook queue item detail

Get webhook queue item detail (hook-incomings): Get the full detail of a single queued item, including its payload when available. Confidential hooks omit payload data.

RequiredhookIdincomingId

List webhook queue items

List webhook queue items (hook-incomings): List items currently waiting in a webhook's processing queue — payloads the webhook received but hasn't handed off to a scenario yet (e.g. because the scenario isn't active).

RequiredhookId

Get webhook queue stats

Get webhook queue stats (hook-incomings): Get the current size and limit of a webhook's processing queue.

RequiredhookId

Get Hook Metadata

Retrieves metadata of the given hook TYPE (not a hook instance — use hooks_get for that), or returns an error when the hook type doesn't exist.

RequiredtypeName

Create webhook/mailhook

Create webhook/mailhook (hooks): Create a new webhook/mailhook.

RequiredteamIdnametypeName

Delete webhook/mailhook

Delete webhook/mailhook (hooks): Delete a webhook/mailhook.

RequiredhookId

Get webhook/mailhook

Get webhook/mailhook (hooks): Get details of a specific webhook/mailhook.

RequiredhookId

Start Webhook Data Structure Detection

Starts learning mode ("Detect new values") on a webhook/mailhook: the hook determines its incoming data structure from the next request it receives, without the scenario running. Learning stops automatically once data arrives.

RequiredhookId

Stop Webhook Data Structure Detection

Stops learning mode ("Detect new values") on a webhook/mailhook without waiting for data.

RequiredhookId

List webhooks/mailhooks

List webhooks/mailhooks (hooks): List webhooks/mailhooks for a specific team.

RequiredteamId

Ping Webhook

Returns the live status of a webhook/mailhook: its address, whether it is attached to a scenario, whether learning mode ("Detect new values") is active, and whether it is gone. `learning: false` after a learn-start means the data structure was captured (or learning was stopped).

RequiredhookId

Update webhook/mailhook

Update webhook/mailhook (hooks): Update an existing webhook/mailhook.

RequiredhookIddata

Get Key Metadata

Retrieves metadata of the given key, or returns an error when the key type doesn't exist.

RequiredtypeName

Delete key

Delete key (keys): Delete a key.

RequiredkeyId

Get key

Get key (keys): Get details of a specific key.

RequiredkeyId

List keys

List keys (keys): List all keys for a team.

RequiredteamId

Create organization

Create organization (organizations): Create a new organization.

RequirednameregionIdtimezoneIdcountryId

Delete organization

Delete organization (organizations): Delete an organization.

RequiredorganizationId

Get organization

Get organization (organizations): Get details of a specific organization.

RequiredorganizationId

List organizations

List organizations (organizations): Lists full organization records. For organization and team ids/names to act with, use the always-available `environment_get` first.

Update organization

Update organization (organizations): Update an existing organization.

RequiredorganizationId

Get private space

Get private space (private-spaces): Get details of a specific private space, including usage totals (operations, transfer, centicredits). Callers who are not members of the space receive a 404 even when the space exists.

RequiredprivateSpaceId

List private spaces

List private spaces (private-spaces): List the private spaces of an organization. Requires the organization's private-spaces feature to be enabled (error IM903 otherwise) and the 'personal team manage' permission. Private spaces cannot be created or deleted through the API — they are provisioned automatically by organization settings.

RequiredorganizationId

Update private space

Update private space (private-spaces): Update a private space's operations limit. Set operationsLimit to null to remove the limit (unlimited); the transfer limit is derived automatically. When the new limit is below the space's current consumption the call fails with IM004 unless 'confirmed' is true — confirming pauses the space.

RequiredprivateSpaceId

Get public template

Get public template (public-templates): Get details of a public template by its URL slug (e.g. "12289-add-webhook-data-to-a-google-sheet"). Use this for templates discovered via public-templates_list.

RequiredtemplateUrl

Get public template blueprint

Get public template blueprint (public-templates): Get the full blueprint of a public template including scenario flow, controller configuration, scheduling, and metadata. Use this for templates discovered via public-templates_list.

RequiredtemplateUrl

List public templates

List public templates (public-templates): Search and list public (approved) templates available for anyone. Supports name-based search for template discovery. Results are sorted by usage by default.

Execute RPC

Executes a Make Remote Procedure Call (RPC) with the provided input. Before executing an RPC, be sure you know its exact name and the input parameters that should be passed to the 'data' field. There is no RPC-listing tool — never guess RPC names. Discover them via 'app-module_get' (requires the 'apps:read' scope): the module's parameter instructions reference the RPCs it uses (e.g. as 'rpc://...' option sources). If 'app-module_get' is not available in this conversation, ask the user for the exact RPC name. You can also use RPCs to provide answers for simple "read" or "list" queries, if the corresponding RPC is available, so it's not needed to create a full Tool to achieve such a thing.

RequiredappNameappVersionrpcNamedata

Fill in scenario custom properties data

Fill in scenario custom properties data (scenario-custom-properties): Fill in custom properties data for a scenario for the first time. Fails with IM005 if the scenario already has data — use scenario-custom-properties_update or scenario-custom-properties_replace instead. Every item marked required in the custom property structure must be given a value. Use custom-property-structure-items_list to see the available items.

RequiredscenarioIdcustomProperties

Delete scenario custom properties data

Delete scenario custom properties data (scenario-custom-properties): Delete all custom properties data for a scenario. This is irreversible.

RequiredscenarioId

Get scenario custom properties data

Get scenario custom properties data (scenario-custom-properties): Get the custom properties data filled in for a scenario.

RequiredscenarioId

Replace scenario custom properties data

Replace scenario custom properties data (scenario-custom-properties): Replace all custom properties data for a scenario. Fails with IM013 if the scenario has no data yet — use scenario-custom-properties_create first. Every item marked required in the structure must be given a value.

RequiredscenarioIdcustomProperties

Update scenario custom properties data

Update scenario custom properties data (scenario-custom-properties): Merge-update custom properties data for a scenario; only the specified items are changed. Fails with IM013 if the scenario has no data yet — use scenario-custom-properties_create first.

RequiredscenarioIdcustomProperties

Assign scenario label

Assign scenario label (scenario-labels): Assign a scenario label to a scenario. The label and the scenario must belong to the same team. Assigning an already-assigned label succeeds without changes. To label many scenarios, call this tool once per scenario.

RequiredlabelIdscenarioId

Create scenario label

Create scenario label (scenario-labels): Create a new scenario label in a team. Labels are team-scoped tags that can be assigned to scenarios. If you do not know the teamId, call users_me to learn it.

RequiredteamIdnamecolour

Delete scenario label

Delete scenario label (scenario-labels): Delete a scenario label. The label is removed from the team catalog and unassigned from every scenario carrying it. This cannot be undone.

RequiredlabelId

List scenario labels

List scenario labels (scenario-labels): List a team's scenario label catalog, including how many scenarios carry each label. Scenario labels are team-scoped tags that can be assigned to scenarios, independent of folders. If you do not know the teamId, find it via organizations_list (each organization lists its teams) or teams_list, or ask the user — never guess IDs.

RequiredteamId

Unassign scenario label

Unassign scenario label (scenario-labels): Remove a scenario label from a scenario. Removing an already-absent assignment succeeds without changes. The label itself stays in the team catalog.

RequiredlabelIdscenarioId

Update scenario label

Update scenario label (scenario-labels): Update the name, colour, or description of an existing scenario label. Provide at least one property to change; omitted properties are left unchanged. Changes are reflected on every scenario carrying the label.

RequiredlabelId

Activate scenario

Activate scenario (scenarios): Activate a scenario. Required before scenarios_run can execute it. If this fails with 'Scenario is already running', the scenario is already active — treat that as success and do not retry.

RequiredscenarioId

Create scenario

Create scenario (scenarios): Create a new scenario from a blueprint. Verify every module name in the blueprint via app-modules_list before creating — never invent module identifiers. The created scenario starts INACTIVE: call scenarios_activate before scenarios_run can execute it.

RequiredteamIdschedulingblueprint

Deactivate scenario

Deactivate scenario (scenarios): Deactivate a scenario. If this fails with 'Scenario is not running', the scenario is already inactive — treat that as success and do not retry.

RequiredscenarioId

Delete scenario

Delete scenario (scenarios): Delete a scenario.

RequiredscenarioId

Get scenario

Get scenario (scenarios): Get a scenario and its blueprint by ID.

RequiredscenarioId

Get scenario interface

Get scenario interface (scenarios): Get the interface for a scenario.

RequiredscenarioId

List scenarios

List scenarios (scenarios): List all scenarios for a team. Results can be narrowed to one folder (optionally including its subfolders) and/or to scenarios carrying at least one of the given scenario labels. Returned scenarios include their assigned labels.

RequiredteamId

Replay scenario execution

Replay scenario execution (scenarios): Replay a past execution of a scenario, re-running it with the trigger data the original execution received. Get candidate execution IDs from executions_list. Only executions whose input data is still stored can be replayed — 'Execution is not replayable' means that execution's data has expired or was never stored, so try a MORE RECENT execution instead of retrying the same one. Only the first ID in executionIds is replayed. The scenario must be ACTIVE. A replay starts a real execution and consumes operations exactly like scenarios_run; it returns the executionId of the NEW execution, which you can inspect with executions_get-detail.

RequiredscenarioIdexecutionIds

Run scenario

Run scenario (scenarios): Execute a scenario with optional input data. The scenario must be ACTIVE — a run of an inactive scenario fails with 'Scenario is not activated', so call scenarios_activate first (newly created scenarios start inactive). Returns an executionId: after a failed or suspicious run, inspect it with executions_get-detail BEFORE retrying or editing the scenario. A scenario cannot run twice concurrently — on 'Scenario is already being executed', wait for the running execution instead of retrying.

RequiredscenarioId

Set scenario interface

Set scenario interface (scenarios): Update the interface for a scenario.

RequiredscenarioIdinterface

Update scenario

Update scenario (scenarios): Update a scenario. The `blueprint` parameter wholesale-REPLACES the existing blueprint (no merging): always fetch the current blueprint with scenarios_get first, edit that JSON, and send the complete result. Tool scenarios (created via tools_create) cannot be blueprint-edited with this tool — use tools_update.

RequiredscenarioId

Show execution result

Renders a scenario execution’s outcome — status, outputs, and consumption — as an interactive widget in the chat, for a past or in-progress run. Only call this when the user explicitly wants the result displayed. Do NOT call this to check on a run you just triggered — `scenarios_run` already renders its own live-updating result and needs no follow-up call. For headless status/output checks while iterating, use `executions_get`/`executions_get-detail` instead. A `RUNNING` status means the execution is still in progress. Requires the `scenarios:read` scope on the scenario’s team: on “Insufficient rights” or “Access denied”, verify the scenarioId via `scenarios_list` instead of retrying — the scenario likely belongs to a team your token cannot read. On “Too Many Requests”, stop polling and wait before the next call.

RequiredscenarioId

Show execution history

Renders a scenario’s execution history as an interactive widget in the chat — each past run with its status, trigger type, duration, and consumption. Only call this when the user explicitly wants the history displayed. Do NOT call this while iterating/debugging — use `executions_list` instead, which returns the same data without rendering a UI.

RequiredscenarioId

Show scenarios

Renders an interactive UI in the chat — a searchable, folder-filterable, sortable list of the team's scenarios showing each scenario's status, used apps, and usage. Only call this when the user explicitly wants the list displayed. Do NOT call this while iterating/authoring — use `scenarios_list` instead, which returns the same data without rendering a UI.

RequiredteamId

Create team

Create team (teams): Create a new team.

RequirednameorganizationId

Delete team

Delete team (teams): Delete a team.

RequiredteamId

Get team

Get team (teams): Get details of a specific team.

RequiredteamId

List teams

List teams (teams): Lists full team records for an organization. For organization and team ids/names to act with, use the always-available `environment_get` first.

RequiredorganizationId

Create new Module Tool

This tool creates a new Tool in the system based on provided parameters. It allows users to define custom tools that can be used in various scenarios. Use it to add new functionalities to the platform by specifying tool details. Use this tool also when you're tasked to perform a simple action. It's easier to configure a tool rather than a whole Scenario. Important! Before creating a tool, call 'app-module_get' to check how the module should actually be mapped, then create the mapping, and only then create the tool with this mapping. Even more important is to call 'app-module_get' with the 'instructions' format requested. That way, you'll get perfect instructions for how to fill in the module's configuration. Don't create unnecessary inputs. Create them only for values that should be dynamic, hardcode everything else in the module parameters. When the Module requires a Credential (Connection or Key) to be set, list the existing connections or keys of the corresponding type to see if there are any available. If there are available connections or keys for the Module, ask the user whether they want to use one of the available connections or keys. When asking this question, also provide the user with an option to not use available connections, and to create a new connection or key instead. In case user chooses an option to create a new connection or key, you should request the User to provide you with a new Connection or Key, for that, use the Credential Request Create Tool. In case there are no available connections or keys of the corresponding type for the Module you are creating, you should also request the User to provide you with a new Connection or Key, for that, use the Credential Request Create Tool. If you need to run the Tool, use 'scenarios_run', passing the Tool ID as the scenarioId. Note: a Tool's blueprint cannot be edited via 'scenarios_update' — use 'tools_update' instead.

RequiredteamIdnamedescriptioninputsmodule

Get Module Tool Details

Retrieves details of a specific Tool by its ID.

RequiredtoolId

Update existing Module Tool

This tool updates an existing Tool's details based on provided parameters. It allows users to modify the properties of a Tool to keep it up-to-date with changing requirements. Use it to refine or correct Tool information as needed.

RequiredtoolId

Get current user

Get current user (users): Returns the current user profile. For organization and team ids, use the always-available `environment_get`.

Validate Blueprint Schema

Validates the overall structure of the Scenario Blueprint against the Schema. STRUCTURAL check only — it does NOT verify that module names exist or that module parameters are correct, so a valid blueprint can still fail at scenarios_create with "Module not found". Verify module names via app-modules_list and module configurations via validate_module_configuration.

Requiredblueprint

Validate Epoch Configuration

Validates the Epoch Configuration of particular Trigger Module.

RequiredorganizationIdteamIdappNameappVersionmoduleNameparametersepoch

Validate Hook Configuration

This tool validates that hook configuration values are correctly set for a given hook type. Use this tool before creating a hook to verify that the configuration is correct. Use this tool to iterate towards a successful validation result. Before generating values, learn instructions by getting the hook config in the "instructions" format.

RequiredorganizationIdteamIdtypeNamevalues

Validate Module Configuration

This tool validates that parameters and mapper collection are correctly configured for a given module in a given app. Use this tool before creating a new Make Tool or Make Scenario to verify that the configuration of modules is correct. Use this tool to iterate towards a successful validation result. Before generating parameters and mapper objects for the module, learn instructions for filling them in by getting the module detail in the "instructions" format. Required fields with declared defaults that you omitted are filled automatically, including fields that only exist after remote resolution; when the result contains "appliedDefaults", the "normalizedValues" object carries the filled configuration. When "valid" is true, send "normalizedValues.default" as "parameters" and "normalizedValues.expect" as "mapper" instead of inventing values for fields you did not see in the schema; when "valid" is false, fix the reported errors on top of those objects first.

RequiredorganizationIdteamIdappNameappVersionmoduleNameparametersmapper

Validate Scenario Interface

Use this tool to validate a typed Scenario Interface before applying changes. Either side (`input`, `output`) may be omitted; only the side(s) supplied are validated.

Validate Scheduling Schema

Validates the Scheduling of the Scenario against the Schema.

Requiredscheduling