@globus/sdk 5.8.0 → 6.0.0-rc.10

package/dist/esm/open-api/types/flows.d.ts

@@ -0,0 +1,2540 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+export interface paths {
+    "/flows": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Retrieve all Flows
+         * @description Query the Flows service for a listing of Flows available to a user
+         *     according to the permissions (role) they have on the Flow.
+         *
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description An opaque token used to iterate through pages of returned Flows.
+                     *     If provided, all other query arguments will be ignored.
+                     *     The marker encodes all state in a given query,
+                     *     therefore it's unnecessary to provide query arguments
+                     *     once an initial marker has been received.
+                     *      */
+                    marker?: string;
+                    /**
+                     * @description The number of results to return in a single paged response.
+                     *
+                     * @example 50
+                     */
+                    per_page?: number;
+                    /**
+                     * @description The page of results to return.
+                     * @example 2
+                     */
+                    page?: number;
+                    /**
+                     * @description Return Flows for which the user has the supplied role. The role the
+                     *     user has on the Flow dictates the operations they can perform. If
+                     *     multiple roles are specified, the user will have at least one of the
+                     *     specified roles on each Flow returned.
+                     *
+                     * @example flow_owner,flow_viewers
+                     */
+                    filter_roles?: ("flow_owner" | "flow_viewers" | "flow_starters" | "flow_administrators" | "run_managers" | "run_monitors")[];
+                    /**
+                     * @deprecated
+                     * @description Return Flows for which the user has the provided role. The
+                     *     role the user has on the Flow dictates the operations they
+                     *     can perform. Roles are cumulative in the sense that
+                     *     having, for example, the "flow_starter" role also implies having
+                     *     the "flow_viewer" role. Thus, specifying "flow_starter" will also
+                     *     include all Flows for which the user has "flow_viewer" role as
+                     *     well. If not provided, only Flows for which the caller has
+                     *     "flow_owner" role will be returned.
+                     *
+                     * @example flow_starter
+                     */
+                    filter_role?: "flow_viewer" | "flow_starter" | "flow_administrator" | "flow_owner" | "run_manager" | "run_monitor";
+                    /**
+                     * @description Performs a case insensitive substring based search on the Flows'
+                     *     scope string fields. If multiple values are specified, each Flow
+                     *     returned is guaranteed to contain at least one of the strings in its
+                     *     scope strings.
+                     *
+                     * @example 0abc,100
+                     */
+                    filter_scope_string?: string[];
+                    /**
+                     * @description Performs a case insensitive substring based search on the Flows' title
+                     *     field. If multiple values are specified, each Flow returned
+                     *     is guaranteed to contain at least one of the strings in its title.
+                     *
+                     * @example hello,science
+                     */
+                    filter_title?: string[];
+                    /**
+                     * @description Performs a case insensitive substring based search on the Flows'
+                     *     subtitle field. If multiple values are specified, each Flow returned
+                     *     is guaranteed to contain at least one of the strings in its
+                     *     subtitle.
+                     *
+                     * @example hello,science
+                     */
+                    filter_subtitle?: string[];
+                    /**
+                     * @description Performs a case insensitive substring based search on the Flows'
+                     *     description field. If multiple values are specified, each Flow returned
+                     *     is guaranteed to contain at least one of the strings in its
+                     *     description.
+                     *
+                     * @example hello,science
+                     */
+                    filter_description?: string[];
+                    /**
+                     * @description Performs a case insensitive substring based search on the Flows'
+                     *     keywords field. If multiple values are specified, each Flow returned
+                     *     is guaranteed to contain at least one of the substrings as a
+                     *     keyword.
+                     *
+                     * @example hello,science
+                     */
+                    filter_keywords?: string[];
+                    /**
+                     * @description Given a one or more patterns, this filter searches against a
+                     *     pre-defined subset of fields for a match. If any of the fields match
+                     *     any of the patterns, the Flow is considered a match.
+                     *
+                     *     The fields that are automatically searched in are:
+                     *       - title
+                     *       - subtitle
+                     *       - flow_owner
+                     *       - description
+                     *       - id
+                     *       - flow_administrators
+                     *
+                     * @example globus
+                     */
+                    filter_fulltext?: string[];
+                    /**
+                     * @description An ordering criteria to apply to the resulting Flows listing. The
+                     *     first value indicates the field to order on, and the second value
+                     *     indicates the sorting order. The first ordering criteria will be
+                     *     used to sort the data, subsequent ordering criteria will be applied
+                     *     for ties.
+                     *
+                     *     Fields that support ordering are:
+                     *       - id
+                     *       - scope_string
+                     *       - flow_owner
+                     *       - flow_administrators
+                     *       - title
+                     *       - created_at
+                     *       - updated_at
+                     *
+                     *     Supported orderings are:
+                     *       - ASC
+                     *       - DESC
+                     *
+                     * @default orderby=id ASC
+                     * @example title ASC,id DESC
+                     */
+                    orderby?: string[];
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The requestor has successfully authenticated and queried the Flow's
+                 *     service for the Flows available for them.
+                 *      */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            flows?: components["schemas"]["FlowResponse"][];
+                            /** @description The number of Flows returned. */
+                            limit?: number;
+                            /** @description An opaque pagination token for iterating through returned
+                             *     Flows.
+                             *      */
+                            marker?: string;
+                            has_next_page?: boolean;
+                        };
+                    };
+                };
+                /** @description There was an issue parsing the query parameters.
+                 *      */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The requestor presented a token with insufficient scopes.
+                 *      */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        /**
+         * Deploy a Flow
+         * @description Deploy a Flow and its schema.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        /** @description The Flow to deploy. */
+                        definition: components["schemas"]["FlowDefinition"];
+                        /** @description A non-unique, human-friendly name used for displaying the provider
+                         *     to end users.
+                         *      */
+                        title?: string;
+                        /** @description A concise summary of the provider’s purpose. */
+                        subtitle?: string;
+                        /** @description A detailed description of the provider for end user display. */
+                        description?: string;
+                        /** @description A set of terms used to categorize the provider which may be used in
+                         *     query and discovery operations. Maximum total length of all
+                         *     keywords is 1024 characters.
+                         *      */
+                        keywords?: string[];
+                        /**
+                         * @description A set of Principal URN values, or the value "public" indicating the
+                         *     identity of users who can view the provider description via
+                         *     introspection or when indexed in any provider catalog service.
+                         *
+                         * @example [
+                         *       "public",
+                         *       "urn:globus:auth:identity:46bd0f56-e24f-11e5-a510-131bef46955c",
+                         *       "urn:globus:groups:id:fdb38a24-03c1-11e3-86f7-12313809f035"
+                         *     ]
+                         */
+                        flow_viewers?: components["schemas"]["PrincipalURN_or_public"][];
+                        /**
+                         * @description A set of Principal URN values, or the value
+                         *     "all_authenticated_users" indicating the identity of users who can
+                         *     use the /run operation to initiate an action on the provider.
+                         *
+                         * @example [
+                         *       "all_authenticated_users",
+                         *       "urn:globus:auth:identity:46bd0f56-e24f-11e5-a510-131bef46955c",
+                         *       "urn:globus:groups:id:fdb38a24-03c1-11e3-86f7-12313809f035"
+                         *     ]
+                         */
+                        flow_starters?: components["schemas"]["PrincipalURN_or_all_authenticated_users"][];
+                        /**
+                         * @description The set of Principal URN values of users who may perform
+                         *     administrative operations, including updating the description
+                         *     itself, on the flow.
+                         *
+                         * @example [
+                         *       "urn:globus:auth:identity:46bd0f56-e24f-11e5-a510-131bef46955c",
+                         *       "urn:globus:groups:id:fdb38a24-03c1-11e3-86f7-12313809f035"
+                         *     ]
+                         */
+                        flow_administrators?: components["schemas"]["PrincipalURN"][];
+                        /** @description A published JSON Schema which input to the Flow must conform
+                         *     to.
+                         *      */
+                        input_schema?: Record<string, never>;
+                        run_managers?: components["schemas"]["RunManagers"];
+                        run_monitors?: components["schemas"]["RunMonitors"];
+                        /**
+                         * Format: uuid
+                         * @description A subscription to associate with this flow.
+                         *
+                         *     If no subscription is specified, the flow may be created
+                         *     but may have limits on how long or how much it can be used.
+                         *
+                         */
+                        subscription_id?: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description The Flow definition was successfully deployed onto the Flows
+                 *     service.
+                 *      */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["FlowResponse"];
+                    };
+                };
+                /** @description The requestor attempted to deploy a malformed Flow.
+                 *      */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The requestor is not authorized to deploy a Flow.
+                 *      */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/flows/validate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Validate a flow
+         * @description Validate a flow definition and its schema.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        /** @description The flow definition. */
+                        definition: components["schemas"]["FlowDefinition"];
+                        /** @description A JSON Schema describing valid input to the flow.
+                         *      */
+                        input_schema?: Record<string, never>;
+                    };
+                };
+            };
+            responses: {
+                /** @description The flow passed all validation checks.
+                 *      */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["FlowValidationResponse"];
+                    };
+                };
+                /** @description The requestor attempted to validate a malformed flow.
+                 *      */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The requestor is not authorized to validate a flow.
+                 *      */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description A conflict was found in the flow definition or input schema.
+                 *      */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The flow definition or input schema failed validation checks.
+                 *      */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["FlowValidationErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/flows/{flow_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The ID for the Flow whose definition is being looked up. */
+                flow_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Retrieve a Flow
+         * @description Get a previously deployed Flow.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description The ID for the Flow whose definition is being looked up. */
+                    flow_id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The requestor has successfully authenticated and queried the Flow's
+                 *     service for a specific Flow definition.
+                 *      */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["FlowResponse"];
+                    };
+                };
+                /** @description The requestor attempted to retrieve a Flow definition for which they
+                 *     did not have access.
+                 *      */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The requestor attempted to retrieve a non-existent Flow, or the
+                 *     requestor did not have permissions to view a Flow.
+                 *      */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        /**
+         * Update a Flow
+         * @description Update a previously deployed Flow.
+         */
+        put: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description The ID for the Flow whose definition is being looked up. */
+                    flow_id: string;
+                };
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        /** @description A new flow definition that will replace the old one.
+                         *
+                         *     Runs that are currently executing will continue to use the definition
+                         *     that they were initially started with.
+                         *      */
+                        definition?: components["schemas"]["FlowDefinition"];
+                        /** @description A JSON schema document.
+                         *
+                         *     When starting the flow, input keys and values must conform to the schema.
+                         *     The Globus Web App uses the input schema to created a guided input page when starting the flow.
+                         *      */
+                        input_schema?: Record<string, never>;
+                        /** @description A non-unique, human-friendly name used for displaying the flow to end users.
+                         *      */
+                        title?: string;
+                        /** @description A short summary of the flow's purpose or functionality.
+                         *      */
+                        subtitle?: string;
+                        /** @description Arbitrary text to describe the Flow.
+                         *      */
+                        description?: string;
+                        /** @description If provided, the value must be the calling user's Globus Auth identity URN,
+                         *     and the user must be a flow administrator.
+                         *
+                         *     It is not possible for non-administrators to take ownership of a flow.
+                         *     Also, it is currently not possible to assign ownership to another user.
+                         *      */
+                        flow_owner?: string;
+                        /** @description A list of Globus Auth identity and group URNs that may administer the flow.
+                         *
+                         *     Flow administrators are able to see the full flow definition,
+                         *     including any parameters listed in a "__Private_Parameters" value.
+                         *      */
+                        flow_administrators?: Record<string, never>[];
+                        /** @description A list of Globus Auth identity and group URNs that may start the flow.
+                         *
+                         *     It is possible to make a flow available for use to all authenticated users
+                         *     -- including those outside your organization or domain --
+                         *     by using the special value "all_authenticated_users".
+                         *
+                         *     Parameters listed in "__Private_Parameters" values in the definition
+                         *     will be removed from the definition when it is viewed by a flow starter.
+                         *      */
+                        flow_starters?: Record<string, never>[];
+                        /** @description A list of Globus Auth identity and group URNs that may see the flow,
+                         *     including its definition and input schema.
+                         *
+                         *     It is possible to make a flow available for viewing to all users
+                         *     -- including those outside your organization or domain --
+                         *     by using the special value "public".
+                         *
+                         *     Parameters listed in "__Private_Parameters" values in the definition
+                         *     will be removed from the definition when it is viewed by a flow starter.
+                         *      */
+                        flow_viewers?: Record<string, never>[];
+                        /** @description A list of keywords that can be used for grouping or identifying flows.
+                         *      */
+                        keywords?: Record<string, never>[];
+                        run_managers?: components["schemas"]["RunManagers"];
+                        run_monitors?: components["schemas"]["RunMonitors"];
+                        subscription_id?: string & (unknown | "DEFAULT");
+                    };
+                };
+            };
+            responses: {
+                /** @description The requestor has successfully authenticated and updated the target
+                 *     Flow definition.
+                 *      */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["FlowResponse"];
+                    };
+                };
+                /** @description The Flow definition update failed due to an attempt to perform a
+                 *     malformed update.
+                 *      */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The requestor attempted to update a Flow for which they did not have
+                 *     access.
+                 *      */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The requestor attempted to update a non-existent Flow, or the
+                 *     requestor did not have permissions to update a Flow.
+                 *      */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        post?: never;
+        /**
+         * Remove a Flow
+         * @description Remove a Flow from the Flow service.
+         */
+        delete: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description The ID for the Flow whose definition is being looked up. */
+                    flow_id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The requestor has successfully removed the Flow from the Flows
+                 *     service.
+                 *      */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["FlowResponse"];
+                    };
+                };
+                /** @description The requestor attempted to modify a Flow for which they did not have
+                 *     access.
+                 *      */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The requestor attempted to remove a non-existent Flow, or the
+                 *     requestor did not have permissions to remove the Flow.
+                 *      */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/mine": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Retrieve all Flows
+         * @deprecated
+         * @description Query the Flows service for a listing of Flows available to a user
+         *     according to the permissions (role) they have on the Flow.
+         *
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /**
+                     * @description Return Flow's for which the user has the supplied role. The role the
+                     *     user has on the Flow dictates the operations they can perform.
+                     *
+                     * @example flow_owner,flow_viewers
+                     */
+                    roles?: ("flow_owner" | "flow_viewers" | "flow_starters" | "flow_administrators")[];
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The requestor has successfully authenticated and queried the Flow's
+                 *     service for the Flows available for them.
+                 *      */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            flows?: components["schemas"]["FlowResponse"][];
+                            /** @description The number of Flows returned. */
+                            limit?: number;
+                            /** @description An opaque pagination token for iterating through returned
+                             *     Flows.
+                             *      */
+                            marker?: string;
+                            has_next_page?: boolean;
+                        };
+                    };
+                };
+                /** @description There was an issue parsing the query parameters.
+                 *      */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The requestor presented a token with insufficient scopes.
+                 *      */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/flows/{flow_id}/run": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The ID for the Flow to run. */
+                flow_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Start a Flow
+         * @description Start a particular Flow, which creates a Run.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description The ID for the Flow to run. */
+                    flow_id: string;
+                };
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        body: components["schemas"]["InputBody"];
+                        run_monitors?: components["schemas"]["RunMonitors"];
+                        run_managers?: components["schemas"]["RunManagers"];
+                        label?: components["schemas"]["Label"];
+                        tags?: components["schemas"]["Tags"];
+                        activity_notification_policy?: components["schemas"]["ActivityNotificationPolicy"];
+                    };
+                };
+            };
+            responses: {
+                /** @description The Run inputs were successfully validated during a dry-run. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The Run was successfully started. */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["FlowRun"];
+                    };
+                };
+                /** @description The Run's input failed validation against the Flow's input schema.
+                 *      */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The requestor presented a token with insufficient scopes.
+                 *      */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The requestor did not have access to run the provided Flow, or the
+                 *     Flow does not exist.
+                 *      */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The input tags did not pass validation. */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description An upstream service has imposed rate limiting.
+                 *     The requestor may resubmit the API request.
+                 *      */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description An upstream service returned an uncorrectable error.
+                 *     The error may or may not occur if the API request is submitted again.
+                 *     It may be possible to resubmit the API request.
+                 *      */
+                502: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/flows/{flow_id}/validate_run": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Validate a run
+         * @description Validate that a run input body will pass the target flow's input schema validation (if any),
+         *     that run metadata will meet the Flows service's metadata constraints,
+         *     and that known scope requirements are met by the user's or client's Globus Auth token.
+         *
+         *     If validation passes, then it is likely that the flow can be started
+         *     with the same inputs and Globus Auth token.
+         *
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        activity_notification_policy?: components["schemas"]["ActivityNotificationPolicy"];
+                        body: components["schemas"]["InputBody"];
+                        label?: components["schemas"]["Label"];
+                        run_managers?: components["schemas"]["RunManagers"];
+                        run_monitors?: components["schemas"]["RunMonitors"];
+                        tags?: components["schemas"]["Tags"];
+                    };
+                };
+            };
+            responses: {
+                /** @description The inputs and Globus Auth token passed validation.
+                 *
+                 *     It is likely that the user or client will be able to start the flow
+                 *     using the same Globus Auth token and input values.
+                 *      */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ValidateRun"];
+                    };
+                };
+                /** @description The input body failed validation against the flow's input schema.
+                 *      */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The user or client is not allowed to run the flow,
+                 *     or the Globus Auth token is missing required scopes.
+                 *      */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/flows/{flow_id}/start": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The ID for the Flow to run. */
+                flow_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Start a Flow
+         * @deprecated
+         * @description Start a particular Flow, which creates a Run.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description The ID for the Flow to run. */
+                    flow_id: string;
+                };
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        body: components["schemas"]["InputBody"];
+                        tags?: components["schemas"]["Tags"];
+                    };
+                };
+            };
+            responses: {
+                /** @description The Run inputs were successfully validated during a dry-run. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The Run was successfully started. */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["FlowRun"];
+                    };
+                };
+                /** @description The Run's input failed validation against the Flow's input schema.
+                 *      */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The requestor presented a token with insufficient scopes.
+                 *      */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The requestor did not have access to run the provided Flow, or the
+                 *     Flow does not exist.
+                 *      */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The input tags did not pass validation. */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description An upstream service has imposed rate limiting.
+                 *     The requestor may resubmit the API request.
+                 *      */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description An upstream service returned an uncorrectable error.
+                 *     The error may or may not occur if the API request is submitted again.
+                 *     It may be possible to resubmit the API request.
+                 *      */
+                502: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runs/{run_id}/release": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The ID for the Run whose data is being released. */
+                run_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Remove a Run
+         * @description Remove the state for a particular invocation of a Flow.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description The ID for the Run whose data is being released. */
+                    run_id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The request was successful. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["FlowRun"];
+                    };
+                };
+                /** @description The requestor is not authorized to access the run or flow,
+                 *     or has not provided access tokens with sufficient privileges.
+                 *      */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The requested Run or Flow was not found. Or, the requestor did not
+                 *     have access to view the Run.
+                 *      */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The requestor attempted to remove the state for a Run which had
+                 *     not yet reached a completed status.
+                 *      */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description An upstream service rate-limited the request to release the Run.
+                 *     The requestor may re-submit the request at a later time.
+                 *      */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The run is in an unexpected state in the Flows service.
+                 *     Please contact Globus support.
+                 *      */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description A request to an upstream service failed for an unknown reason.
+                 *     The requestor can re-submit the request or contact Globus support.
+                 *      */
+                502: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/flows/{flow_id}/runs/{run_id}/resume": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The ID for the Flow which launched the Run. */
+                flow_id: string;
+                /** @description The ID for the Run whose data is being resumed. */
+                run_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Resume a Run
+         * @description Attempt to resume a Run, particularly when it has reached a
+         *     status of INACTIVE. A Flow Run may reach an INACTIVE status
+         *     when an Action type state within the Flow returns its status
+         *     as INACTIVE. The resume operation on the Flow Run provides a
+         *     hint that the cause of the Action becoming INACTIVE may have
+         *     been cleared, and thus the resume operation on the Action
+         *     Provider should be invoked to allow the Action state to resume
+         *     and thus resume the Flow Run.
+         *
+         *     In the particular case that an Action state is INACTIVE with a
+         *     code value of "ConsentRequired" it is further assumed that the
+         *     Bearer token provided in the Authorization header on the
+         *     resume operation now carries sufficient consents to continue
+         *     the INACTIVE Action. Thus, the Flow service will use the
+         *     Bearer token to generate new dependent tokens for running the
+         *     Action and use these tokens to request that the Action be
+         *     resumed at the Action Provider.
+         *
+         *     Note again that in reasons other than "ConsentRequired" for a
+         *     Flow or Action to go INACTIVE, the resume operation is just a
+         *     hint. For example, when the code is "ActivationRequired,"
+         *     indicating that a Globus collection or endpoint needs to be
+         *     Activated by the user, performing that Activation out-of-band
+         *     from the Flow will allow the Flow to proceed even without the
+         *     resume operation as the Action is periodically polled for
+         *     progress. Performing the resume operation may simply cause a
+         *     poll to happen more quickly and thus allow the Action to
+         *     resume more quickly.
+         *
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description The ID for the Flow which launched the Run. */
+                    flow_id: string;
+                    /** @description The ID for the Run whose data is being resumed. */
+                    run_id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The request was successful. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["FlowRun"];
+                    };
+                };
+                /** @description The requested Run or Flow was not found. Or, the requestor did not
+                 *     have access to manage the Run.
+                 *      */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/flows/{flow_id}/actions/{action_id}/resume": paths["/flows/{flow_id}/runs/{run_id}/resume"];
+    "/runs/{action_id}/resume": paths["/flows/{flow_id}/runs/{run_id}/resume"];
+    "/flows/{flow_id}/{run_id}/resume": paths["/flows/{flow_id}/runs/{run_id}/resume"];
+    "/runs/{run_id}/cancel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The ID for the Run to cancel. */
+                run_id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Cancel a Run
+         * @description Cancel the execution for a particular Run of a Flow.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description The ID for the Run to cancel. */
+                    run_id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The request was successfully received. */
+                202: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["FlowRun"];
+                    };
+                };
+                /** @description The requested Run or Flow was not found. Or, the requestor did not
+                 *     have access to view the Run.
+                 *      */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The service encountered an Upstream error when attempting to cancel
+                 *     the Run.
+                 *      */
+                502: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/flows/{flow_id}/runs/{run_id}/log": {
+        parameters: {
+            query?: {
+                /** @description An integer limit on the number of log records returned. */
+                limit?: number;
+                /** @description A flag to indicate if log records should be returned in reverse order.
+                 *      */
+                reverse_order?: boolean;
+                /** @description A token used to iterate through pages of returned log records.
+                 *      */
+                pagination_token?: string;
+            };
+            header?: never;
+            path: {
+                /** @description The ID for the Flow which launched the Run. */
+                flow_id: string;
+                /** @description The ID for the Run whose log is getting pulled. */
+                run_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Get execution details on a Run
+         * @description Retrieve detailed execution information for a particular Flow Run
+         *
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description An integer limit on the number of log records returned. */
+                    limit?: number;
+                    /** @description A flag to indicate if log records should be returned in reverse order.
+                     *      */
+                    reverse_order?: boolean;
+                    /** @description A token used to iterate through pages of returned log records.
+                     *      */
+                    pagination_token?: string;
+                };
+                header?: never;
+                path: {
+                    /** @description The ID for the Flow which launched the Run. */
+                    flow_id: string;
+                    /** @description The ID for the Run whose log is getting pulled. */
+                    run_id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The request was successfully received. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @description The number of log states returned. */
+                            limit: number;
+                            /** @description An opaque pagination token for iterating through returned
+                             *     records. If there are no more entries, this field will not
+                             *     exist.
+                             *      */
+                            marker?: string;
+                            has_next_page: boolean;
+                            entries: Record<string, never>[];
+                        };
+                    };
+                };
+                /** @description There was an issue parsing the query parameters.
+                 *      */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The requested Action or Flow was not found. Or, the
+                 *     requestor did not have access to view the Action.
+                 *      */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/flows/{flow_id}/actions/{action_id}/log": paths["/flows/{flow_id}/{run_id}/log"];
+    "/runs/{action_id}/log": paths["/flows/{flow_id}/{run_id}/log"];
+    "/flows/{flow_id}/{run_id}/log": paths["/flows/{flow_id}/runs/{run_id}/log"];
+    "/flows/{flow_id}/runs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The ID for the Flow which launched the Runs. */
+                flow_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Get a Flow's Runs
+         * @description Retrieve a listing of Runs launched from a particular Flow. If hitting
+         *     the *\/actions endpoint, the response will list the Runs under a
+         *     "actions" key. If hitting the *\/runs endpoint, the response will list
+         *     the Runs under a "runs" key.
+         *
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description An opaque token used to iterate through pages of returned Actions.
+                     *     If provided, all other query arguments will be ignored.
+                     *     The marker encodes all state in a given query,
+                     *     therefore it's unnecessary to provide query arguments
+                     *     once an initial marker has been received.
+                     *      */
+                    marker?: string;
+                    /**
+                     * @deprecated
+                     * @description ("marker" is now the preferred name for this parameter.)
+                     *     An opaque token used to iterate through pages of returned Actions. If
+                     *     provided, all other query arguments will be ignored. The
+                     *     pagination_token encodes all state in a given query, therefore it's
+                     *     unnecessary to provide query arguments once an initial token has been
+                     *     received.
+                     *
+                     */
+                    pagination_token?: string;
+                    /**
+                     * @description The number of results to return in a single paged response.
+                     *
+                     * @example 50
+                     */
+                    per_page?: number;
+                    /**
+                     * @description The page of results to return.
+                     * @example 2
+                     */
+                    page?: number;
+                    /**
+                     * @description Return Actions for which the user has the supplied role. The role the
+                     *     user has on the Action dictates the operations they can perform.
+                     *     If multiple roles are specified, the user will have at least one of
+                     *     the specified roles on each Action returned.
+                     *
+                     * @example run_manager
+                     */
+                    filter_roles?: ("run_owner" | "run_manager" | "run_monitor" | "flow_run_manager" | "flow_run_monitor")[];
+                    /**
+                     * @deprecated
+                     * @description Return Actions for which the user has the provided
+                     *     role. The role the user has on the Action dictates the
+                     *     operations they can perform. Roles are cumulative in the
+                     *     sense that having, for example, the "run_manager" role also
+                     *     implies having the "run_monitor" role. Thus, specifying
+                     *     manager will also include all Actions for which the user
+                     *     has "run_monitor" role as well. If not provided, only Actions
+                     *     for which the caller has "run_owner" role will be returned.
+                     *
+                     * @example run_manager
+                     */
+                    filter_role?: "run_monitor" | "run_manager" | "run_owner" | "flow_run_manager" | "flow_run_monitor";
+                    /**
+                     * @description Return Actions which are in the specified state. The state of the
+                     *     Action dictates the operations which can performed on them. If
+                     *     multiple statuses are specified, each Action returned will be in one
+                     *     of the specified states. By default, Actions in any state will be
+                     *     returned.
+                     *
+                     * @example FAILED,INACTIVE
+                     */
+                    filter_status?: ("SUCCEEDED" | "FAILED" | "ENDED" | "ACTIVE" | "INACTIVE")[];
+                    /**
+                     * @description Performs a case insensitive string based search on the Actions'
+                     *     label fields. If multiple values are specified, each Action returned
+                     *     is guaranteed to contain at least one of the strings in its label.
+                     *
+                     * @example science,tests
+                     */
+                    filter_label?: string[];
+                    /**
+                     * @description Given a pair of comma separated ISO 8601 date/time strings, filter
+                     *     results to only those Actions whose completion time is within the
+                     *     specified range. If one of the dates is omitted, it forms an open
+                     *     range, so "dt," returns all records with date greater or equal to
+                     *     dt, and ",dt" returns all records with dates less than dt. If there
+                     *     is no comma, it is treated in the same way as "dt,". Results will
+                     *     contain Actions which completed between the first date/time string
+                     *     onwards, up to (but not including) the second date/time string.
+                     *     Note that Actions which are still running will have null completion
+                     *     times and thus cannot be filtered by this field.
+                     *
+                     * @example 2021-03-09T21:52:14,2021-03-09T21:53
+                     */
+                    filter_completion_time?: string;
+                    /**
+                     * @description Given a pair of comma separated ISO 8601 date/time strings, filter
+                     *     results to only those Actions which started running within the
+                     *     specified range. If one of the dates is omitted, it forms an open
+                     *     range, so "dt," returns all records with date greater or equal to
+                     *     dt, and ",dt" returns all records with dates less than dt. If there
+                     *     is no comma, it is treated in the same way as "dt,". Results will
+                     *     contain Actions which began between the first date/time string
+                     *     onwards, up to (but not including) the second date/time string.
+                     *
+                     * @example 2021-03-09T21:52:14,2021-03-09T21:53
+                     */
+                    filter_start_time?: string;
+                    /**
+                     * @description An ordering criteria to apply to the resulting Action listing. The
+                     *     first value indicates the field to order on, and the second value
+                     *     indicates the sorting order. The first ordering criteria will be
+                     *     used to sort the data, subsequent ordering criteria will be applied
+                     *     for ties.
+                     *
+                     *     Fields that support ordering are:
+                     *       - id
+                     *       - start_time
+                     *       - completion_time
+                     *       - status
+                     *       - label
+                     *
+                     *     Supported orderings are:
+                     *       - ASC
+                     *       - DESC
+                     *
+                     * @default orderby=id ASC
+                     * @example start_time ASC,id DESC
+                     */
+                    orderby?: string[];
+                };
+                header?: never;
+                path: {
+                    /** @description The ID for the Flow which launched the Runs. */
+                    flow_id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The request was successfully received. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @description An opaque pagination token for iterating through returned
+                             *     Actions. If there are no more entries, this field will not
+                             *     exist.
+                             *      */
+                            marker?: string;
+                            has_next_page: boolean;
+                            actions: components["schemas"]["FlowRun"][];
+                        };
+                    };
+                };
+                /** @description The requestor presented a token with insufficient scopes.
+                 *      */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The Flow does not exist or the requestor did not have access to
+                 *     enumerate the Flow's Actions.
+                 *      */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/flows/{flow_id}/actions": paths["/flows/{flow_id}/runs"];
+    "/runs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List all Runs
+         * @description Retrieve a listing of Actions/Runs launched across all Flows. If hitting
+         *     the *\/actions endpoint, the response will list the Runs under a
+         *     "actions" key. If hitting the *\/runs endpoint, the response will list
+         *     the Runs under a "runs" key.
+         *
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description An opaque token used to iterate through pages of returned Actions.
+                     *     If provided, all other query arguments will be ignored.
+                     *     The marker encodes all state in a given query,
+                     *     therefore it's unnecessary to provide query arguments
+                     *     once an initial marker has been received.
+                     *      */
+                    marker?: string;
+                    /**
+                     * @deprecated
+                     * @description ("marker" is now the preferred name for this parameter.)
+                     *     An opaque token used to iterate through pages of returned Actions. If
+                     *     provided, all other query arguments will be ignored. The
+                     *     pagination_token encodes all state in a given query, therefore it's
+                     *     unnecessary to provide query arguments once an initial token has been
+                     *     received.
+                     *
+                     */
+                    pagination_token?: string;
+                    /**
+                     * @description The number of results to return in a single paged response.
+                     *
+                     * @example 50
+                     */
+                    per_page?: number;
+                    /**
+                     * @description The page of results to return.
+                     * @example 2
+                     */
+                    page?: number;
+                    /**
+                     * @description Return Runs for which the user has the supplied role. The role the
+                     *     user has on the Action dictates the operations they can perform.
+                     *     If multiple roles are specified, the user will have at least one of
+                     *     the specified roles on each Action returned.
+                     *
+                     * @example run_owner,run_managers
+                     */
+                    filter_roles?: ("run_owner" | "run_managers" | "run_monitors" | "flow_run_managers" | "flow_run_monitors")[];
+                    /**
+                     * @deprecated
+                     * @description Return Runs for which the user has the provided
+                     *     role. The role the user has on the Runs dictates the
+                     *     operations they can perform. Roles are cumulative in the
+                     *     sense that having, for example, the "run_manager" role also
+                     *     implies having the "run_monitor" role. Thus, specifying
+                     *     manager will also include all Runs for which the user
+                     *     has "run_monitor" role as well. If not provided, only Runs
+                     *     for which the caller has "run_owner" role will be returned.
+                     *
+                     * @example run_manager
+                     */
+                    filter_role?: "run_monitor" | "run_manager" | "run_owner";
+                    /**
+                     * @description Return Actions which are in the specified state. The state of the
+                     *     Action dictates the operations which can performed on them. If
+                     *     multiple statuses are specified, each Action returned will be in one
+                     *     of the specified states. By default, Actions in any state will be
+                     *     returned.
+                     *
+                     * @example FAILED,INACTIVE
+                     */
+                    filter_status?: ("SUCCEEDED" | "FAILED" | "ENDED" | "ACTIVE" | "INACTIVE")[];
+                    /**
+                     * @description Performs a case insensitive string based search on the Actions'
+                     *     label fields. If multiple values are specified, each Action returned
+                     *     is guaranteed to contain at least one of the strings in its label.
+                     *
+                     * @example science,tests
+                     */
+                    filter_label?: string[];
+                    /**
+                     * @description Performs a case insensitive string based search to filter for
+                     *     Actions which have parent Flow's with a matching title(s). If
+                     *     multiple values are specified, each Action returned will have a
+                     *     parent Flow with a title matching at least one of the strings.
+                     *
+                     * @example globus,tests
+                     */
+                    filter_flow_title?: string[];
+                    /**
+                     * @description Performs an equality based search to filter for Runs which were
+                     *     initiated from the specified Flow ID(s). If multiple values are
+                     *     specified, each Run returned will have been initiated from at least
+                     *     one of the specified Flow IDs.
+                     *
+                     * @example 6086d817-19d9-4f5b-9329-22ed12d4d3dd,71a70751-19a5-4d19-998e-0709c40321e9
+                     */
+                    filter_flow_id?: string[];
+                    /**
+                     * @description Given a pair of comma separated ISO 8601 date/time strings, filter
+                     *     results to only those Actions whose completion time is within the
+                     *     specified range. If one of the dates is omitted, it forms an open
+                     *     range, so "dt," returns all records with date greater or equal to
+                     *     dt, and ",dt" returns all records with dates less than dt. If there
+                     *     is no comma, it is treated in the same way as "dt,". Results will
+                     *     contain Actions which completed between the first date/time string
+                     *     onwards, up to (but not including) the second date/time string.
+                     *     Note that Actions which are still running will have null completion
+                     *     times and thus cannot be filtered by this field.
+                     *
+                     * @example 2021-03-09T21:52:14,2021-03-09T21:53
+                     */
+                    filter_completion_time?: string;
+                    /**
+                     * @description Given a pair of comma separated ISO 8601 date/time strings, filter
+                     *     results to only those Actions which started running within the
+                     *     specified range. If one of the dates is omitted, it forms an open
+                     *     range, so "dt," returns all records with date greater or equal to
+                     *     dt, and ",dt" returns all records with dates less than dt. If there
+                     *     is no comma, it is treated in the same way as "dt,". Results will
+                     *     contain Actions which began between the first date/time string
+                     *     onwards, up to (but not including) the second date/time string.
+                     *
+                     * @example 2021-03-09T21:52:14,2021-03-09T21:53
+                     */
+                    filter_start_time?: string;
+                    /**
+                     * @description An ordering criteria to apply to the resulting Action listing. The
+                     *     first value indicates the field to order on, and the second value
+                     *     indicates the sorting order. The first ordering criteria will be
+                     *     used to sort the data, subsequent ordering criteria will be applied
+                     *     for ties.
+                     *
+                     *     Fields that support ordering are:
+                     *       - id
+                     *       - start_time
+                     *       - completion_time
+                     *       - status
+                     *       - label
+                     *       - run_owner
+                     *       - flow_title
+                     *
+                     *     Supported orderings are:
+                     *       - ASC
+                     *       - DESC
+                     *
+                     * @default orderby=start_time DESC
+                     * @example start_time ASC,id DESC
+                     */
+                    orderby?: string[];
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The request was successfully received. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @description An opaque pagination token for iterating through returned
+                             *     Actions. If there are no more entries, this field will not
+                             *     exist.
+                             *      */
+                            marker?: string;
+                            has_next_page: boolean;
+                            actions?: components["schemas"]["FlowRun"][];
+                            runs?: components["schemas"]["FlowRun"][];
+                        };
+                    };
+                };
+                /** @description The requestor presented a token with insufficient scopes.
+                 *      */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The Flow does not exist or the requestor did not have access to
+                 *     enumerate the Actions.
+                 *      */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runs/{run_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The ID for the Run. */
+                run_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Get details about a run
+         * @description Get details about a run.
+         *
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /**
+                     * @description If present and set to a true value,
+                     *     metadata about the associated flow will be included.
+                     *
+                     * @example true
+                     */
+                    include_flow_description?: true | true | false | false;
+                };
+                header?: never;
+                path: {
+                    /** @description The ID for the Run. */
+                    run_id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The request was successfully received. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["FlowRunWithFlowEmbed"];
+                    };
+                };
+                /** @description The requestor presented a token with insufficient scopes.
+                 *      */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The Run does not exist or the requestor did not have access to
+                 *     view the Run's status.
+                 *      */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        /**
+         * Update a Run's metadata
+         * @description Modify a Run's metadata.
+         *
+         *     By default only the Run initiator is able to modify a Run's metadata.
+         *     Note that delegating manage access to a principal will allow them
+         *     to further alter the principals with monitor and manage access.
+         *
+         */
+        put: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description The ID for the Run. */
+                    run_id: string;
+                };
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["RunUpdate"];
+                };
+            };
+            responses: {
+                /** @description The request was successfully received. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["FlowRun"];
+                    };
+                };
+                /** @description The requestor presented a token with insufficient scopes.
+                 *      */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The Run does not exist or the requestor did not have access to
+                 *     modify the Run.
+                 *      */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The request's JSON body did not pass schema validation.
+                 *      */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description An upstream service has imposed rate limiting.
+                 *     The requestor may resubmit the API request.
+                 *      */
+                429: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description An unknown upstream service error occurred.
+                 *     The problem may be resolved by re-submitting the API request.
+                 *      */
+                502: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/runs/{run_id}/definition": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The UUID of the Run. */
+                run_id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Get the Flow definition and input schema that were used to start a Run
+         * @description Flow definitions and input schemas may be updated after a Run has been started.
+         *
+         *     This route allows users to view the Flow definition and input schema
+         *     that were used to start a given Run.
+         *
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description The UUID of the Run. */
+                    run_id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The request was successfully received. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["GetRunDefinitionResponse"];
+                    };
+                };
+                /** @description The requestor presented a token with insufficient scopes.
+                 *      */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description The Run does not exist or the requestor did not have access to view the Run.
+                 *      */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/batch/runs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Update metadata for multiple Runs. */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        filters: {
+                            run_ids: string[];
+                        };
+                        set?: components["schemas"]["BatchRunUpdateSetOperation"];
+                        add?: components["schemas"]["BatchRunUpdateOperation"];
+                        remove?: components["schemas"]["BatchRunUpdateOperation"];
+                    };
+                };
+            };
+            responses: never;
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        FlowDefinition: {
+            Comment?: string;
+            StartAt: string;
+            States: {
+                [key: string]: components["schemas"]["Pass"] | components["schemas"]["Action"] | components["schemas"]["Wait"] | components["schemas"]["Choice"] | components["schemas"]["ExpressionEval"] | components["schemas"]["Fail"];
+            };
+        };
+        FlowRun: {
+            /** @description The ID for a particular Flow invocation. Analogous to a run_id.
+             *      */
+            action_id: string;
+            /** @description The ID for a particular Flow invocation. Analogous to an action_id.
+             *      */
+            run_id: string;
+            /** @description The Flow to which this Run belongs.
+             *      */
+            flow_id: string;
+            /**
+             * Format: date-time
+             * @description A timezone-aware ISO8601 format string that represents the time at
+             *     which the last update to this Run's Flow occurred.
+             *
+             */
+            flow_last_updated: string;
+            /**
+             * Format: date-time
+             * @description A timezone-aware ISO8601 format string that represents the time at
+             *     which this Run started.
+             *
+             */
+            start_time: string;
+            /**
+             * Format: date-time
+             * @description A timezone-aware ISO8601 format string that represents the time at
+             *     which this Run reached a completed status.
+             *
+             */
+            completion_time: string;
+            label: components["schemas"]["Label"];
+            /**
+             * @description The current state of the Run.
+             * @enum {string}
+             */
+            status: "SUCCEEDED" | "FAILED" | "ENDED" | "ACTIVE" | "INACTIVE";
+            display_status?: string;
+            details: Record<string, never>;
+            run_owner: components["schemas"]["PrincipalURN"];
+            run_monitors?: components["schemas"]["RunMonitors"];
+            run_managers?: components["schemas"]["RunManagers"];
+            /**
+             * @description The role the requesting user has on the Run.
+             *
+             * @enum {string}
+             */
+            user_role: "run_monitor" | "run_manager" | "run_owner";
+            tags: components["schemas"]["Tags"];
+        };
+        ValidateRun: {
+            /**
+             * @description A message indicating the validation was successful
+             *
+             * @example success
+             */
+            message: string;
+        };
+        GetRunDefinitionResponse: {
+            /** @description The Flow used to start the Run.
+             *      */
+            flow_id: string;
+            /** @description The definition of the Flow at the time the Run was started.
+             *      */
+            definition: Record<string, never>;
+            /** @description The input schema of the Flow at the time the Run was started.
+             *      */
+            input_schema: Record<string, never>;
+        };
+        FlowEmbed: {
+            /** @description The unique identifier for the Flow. */
+            id: string;
+            /** @description The user with primary responsibility for the Flow. */
+            flow_owner?: components["schemas"]["PrincipalURN"];
+            /**
+             * Format: date-time
+             * @description A timezone-aware ISO8601 format string that represents the time at
+             *     which the Flow was created.
+             *
+             */
+            created_at: string;
+            /**
+             * Format: date-time
+             * @description A timezone-aware ISO8601 format string that represents the time at
+             *     which the Flow was last updated.
+             *
+             */
+            updated_at?: string;
+            /**
+             * Format: date-time
+             * @description A timezone-aware ISO8601 format string that represents the time at
+             *     which the Flow was deleted (not present if the Flow has not been deleted).
+             *
+             */
+            deleted_at?: string;
+            /** @description A non-unique, human-friendly name used for displaying the Flow to end users.
+             *      */
+            title: string;
+            /** @description A concise summary of the Flow's purpose. */
+            subtitle?: string;
+            /** @description A detailed description of the Flow for end user display. */
+            description?: string;
+            /** @description A set of terms used to categorize the Flow which may be used in
+             *     query and discovery operations.
+             *      */
+            keywords?: string[];
+        };
+        FlowRunWithFlowEmbed: components["schemas"]["FlowRun"] & {
+            flow_description?: components["schemas"]["FlowEmbed"];
+        };
+        RunUpdate: {
+            label?: components["schemas"]["Label"];
+            run_monitors?: components["schemas"]["RunMonitors"];
+            run_managers?: components["schemas"]["RunManagers"];
+            tags?: components["schemas"]["Tags"];
+        };
+        /**
+         * Activity notification policy
+         * @description The email notification policy for the run.
+         */
+        ActivityNotificationPolicy: {
+            /**
+             * @description The set of statuses on which to notify the run's owner by email.
+             *
+             * @default [
+             *       "INACTIVE"
+             *     ]
+             */
+            status: ("INACTIVE" | "FAILED" | "SUCCEEDED")[];
+        };
+        /**
+         * Input body
+         * @description The input body that will be passed into the flow when it starts.
+         *     If the flow defines an input schema, the input body will be validated against the input schema.
+         *     If there is no input schema, no validation will be performed.
+         */
+        InputBody: {
+            [key: string]: unknown;
+        };
+        /**
+         * Label
+         * @description A short, human-readable description of the run.
+         * @example Generate a report for experiment xDA202-batch-3
+         */
+        Label: string;
+        /**
+         * Run managers
+         * @description A list of Globus Auth identity and group URNs that may manage runs of the flow.
+         *
+         *     "Managing" operations include updating, canceling, and deleting the run.
+         *
+         *     Only users with the "run_manager" role will be able to view this list.
+         *     Users with only the "run_monitor" role will see an empty list.
+         *
+         */
+        RunManagers: components["schemas"]["PrincipalURN"][];
+        /**
+         * Run monitors
+         * @description A list of Globus Auth identity and group URNs that may monitor runs of the flow.
+         *
+         *     "Monitoring" operations include checking the run status and its logs.
+         *
+         *     Only users with the "run_manager" role will be able to view this list.
+         *     Users with only the "run_monitor" role will see an empty list.
+         *
+         */
+        RunMonitors: components["schemas"]["PrincipalURN"][];
+        /**
+         * Tags
+         * @description A list of tags to associate with the run.
+         *
+         *     Tags are normalized by stripping leading and trailing whitespace,
+         *     and by replacing all whitespace with a single space.
+         *
+         *     When updating a run, existing tags will be overwritten.
+         *     This means that an empty array will delete all existing tags.
+         *
+         * @example [
+         *       "Experiment:xDA202",
+         *       "Site:Nautilus",
+         *       "Friday COB Report"
+         *     ]
+         */
+        Tags: string[];
+        /**
+         * @description A URN representation of an Identity in Globus either of a user from
+         *     Globus Auth or a group from Globus Groups.
+         *
+         * @example urn:globus:auth:identity:46bd0f56-e24f-11e5-a510-131bef46955c
+         */
+        PrincipalURN: string;
+        JsonPathPattern: string;
+        NextOrEnd: {
+            Next?: string;
+            End?: boolean;
+        } & (unknown | unknown);
+        Parameters: {
+            Parameters?: components["schemas"]["JsonPathPattern"];
+        };
+        InputPath: {
+            InputPath?: components["schemas"]["JsonPathPattern"];
+        };
+        ResultPath: {
+            ResultPath?: components["schemas"]["JsonPathPattern"];
+        };
+        ParametersOrInputPathNotRequired: components["schemas"]["Parameters"] & components["schemas"]["InputPath"];
+        ParametersOrInputPath: (components["schemas"]["Parameters"] & components["schemas"]["InputPath"]) & (unknown | unknown);
+        Pass: {
+            Type?: string;
+            Comment?: unknown;
+            Next?: unknown;
+            End?: unknown;
+            InputPath?: unknown;
+            Parameters?: unknown;
+            ResultPath?: unknown;
+        } & components["schemas"]["NextOrEnd"] & components["schemas"]["ParametersOrInputPathNotRequired"] & components["schemas"]["ResultPath"];
+        Catch: {
+            Catch?: ({
+                ErrorEquals: string[];
+                Next: string;
+                ResultPath?: unknown;
+            } & components["schemas"]["ResultPath"])[];
+        };
+        Action: {
+            /** Format: uri */
+            ActionUrl: string;
+            /** Format: uri */
+            ActionScope?: string;
+            RunAs?: string;
+            /** @default false */
+            ExceptionOnActionFailure: boolean;
+            WaitTime?: number;
+            Type: string;
+            Comment?: unknown;
+            Next?: unknown;
+            End?: unknown;
+            InputPath?: unknown;
+            Parameters?: unknown;
+            ResultPath?: unknown;
+            Catch?: unknown;
+        } & components["schemas"]["NextOrEnd"] & components["schemas"]["ParametersOrInputPath"] & components["schemas"]["ResultPath"] & components["schemas"]["Catch"];
+        ExpressionEval: {
+            Type?: string;
+            Comment?: unknown;
+            Parameters: unknown;
+            ResultPath: unknown;
+            Next: string;
+        } & components["schemas"]["Parameters"] & components["schemas"]["ResultPath"];
+        Wait: {
+            Type?: string;
+            Comment?: unknown;
+            Next?: string;
+            Seconds?: number;
+            SecondsPath?: components["schemas"]["JsonPathPattern"];
+            /** Format: date-time */
+            Timestamp?: string;
+            TimestampPath?: components["schemas"]["JsonPathPattern"];
+        } & (unknown | unknown | unknown | unknown);
+        ChoiceRule: {
+            And?: components["schemas"]["ChoiceRule"][];
+            Or?: components["schemas"]["ChoiceRule"][];
+            Not?: components["schemas"]["ChoiceRule"];
+            Variable?: string;
+            StringEquals?: string;
+            StringEqualsPath?: components["schemas"]["JsonPathPattern"];
+            StringLessThan?: string;
+            StringLessThanPath?: components["schemas"]["JsonPathPattern"];
+            StringGreaterThan?: string;
+            StringGreaterThanPath?: components["schemas"]["JsonPathPattern"];
+            StringLessThanEquals?: string;
+            StringLessThanEqualsPath?: components["schemas"]["JsonPathPattern"];
+            StringGreaterThanEquals?: string;
+            StringGreaterThanEqualsPath?: components["schemas"]["JsonPathPattern"];
+            StringMatches?: string;
+            NumericEquals?: number;
+            NumericEqualsPath?: components["schemas"]["JsonPathPattern"];
+            NumericLessThan?: number;
+            NumericLessThanPath?: components["schemas"]["JsonPathPattern"];
+            NumericGreaterThan?: number;
+            NumericGreaterThanPath?: components["schemas"]["JsonPathPattern"];
+            NumericLessThanEquals?: number;
+            NumericLessThanEqualsPath?: components["schemas"]["JsonPathPattern"];
+            NumericGreaterThanEquals?: number;
+            NumericGreaterThanEqualsPath?: components["schemas"]["JsonPathPattern"];
+            BooleanEquals?: boolean;
+            BooleanEqualsPath?: components["schemas"]["JsonPathPattern"];
+            /** Format: date-time */
+            TimestampEquals?: string;
+            TimestampEqualsPath?: components["schemas"]["JsonPathPattern"];
+            /** Format: date-time */
+            TimestampLessThan?: string;
+            TimestampLessThanPath?: components["schemas"]["JsonPathPattern"];
+            /** Format: date-time */
+            TimestampGreaterThan?: string;
+            TimestampGreaterThanPath?: components["schemas"]["JsonPathPattern"];
+            /** Format: date-time */
+            TimestampLessThanEquals?: string;
+            TimestampLessThanEqualsPath?: components["schemas"]["JsonPathPattern"];
+            /** Format: date-time */
+            TimestampGreaterThanEquals?: string;
+            TimestampGreaterThanEqualsPath?: components["schemas"]["JsonPathPattern"];
+            IsNull?: boolean;
+            IsPresent?: boolean;
+            IsNumeric?: boolean;
+            IsString?: boolean;
+            IsBoolean?: boolean;
+            IsTimestamp?: boolean;
+        } & (unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown | unknown);
+        Choice: {
+            Type?: string;
+            Comment?: string;
+            Default?: string;
+            Choices: ({
+                Next?: string;
+            } & components["schemas"]["ChoiceRule"])[];
+        };
+        Fail: {
+            Type?: string;
+            Comment?: string;
+            Cause?: string;
+            Error?: string;
+        };
+        FlowResponse: {
+            /** @description The unique identifier for the Flow. */
+            id?: string;
+            /** @description The Flow to deploy. */
+            definition?: components["schemas"]["FlowDefinition"];
+            /** @description A JSON Schema compliant definition of the format of the `body` field
+             *     when requesting a Flow be run.
+             *      */
+            input_schema?: Record<string, never>;
+            /**
+             * Format: uri
+             * @description The scope of any bearer token to be used on authenticated accesses
+             *     to the Flow.
+             *
+             */
+            globus_auth_scope?: string;
+            /** @description A list of scopes according to RunAs values as defined in the Flow.
+             *      */
+            globus_auth_scopes_by_RunAs?: string[];
+            /**
+             * @description The role the requesting user has on the Flow.
+             *
+             * @enum {string}
+             */
+            user_role?: "flow_viewer" | "flow_starter" | "flow_administrator" | "flow_owner";
+            /**
+             * @description A set of Principal URN values, or the value "public"
+             *     indicating the identity of users who can view the Flow
+             *     definition. Only calling users with the "administrator"
+             *     role will be provided this list. Otherwise, the value
+             *     will always be an empty list.
+             *
+             * @example [
+             *       "public",
+             *       "urn:globus:auth:identity:46bd0f56-e24f-11e5-a510-131bef46955c",
+             *       "urn:globus:groups:id:fdb38a24-03c1-11e3-86f7-12313809f035"
+             *     ]
+             */
+            flow_viewers?: components["schemas"]["PrincipalURN_or_public"][];
+            /**
+             * @description A set of Principal URN values, or the value
+             *     "all_authenticated_users" indicating the identity of users
+             *     who can initiate a run of the Flow. Only calling users
+             *     with the "administrator" role will be provided this
+             *     list. Otherwise, the value will always be an empty list.
+             *
+             * @example [
+             *       "all_authenticated_users",
+             *       "urn:globus:auth:identity:46bd0f56-e24f-11e5-a510-131bef46955c",
+             *       "urn:globus:groups:id:fdb38a24-03c1-11e3-86f7-12313809f035"
+             *     ]
+             */
+            flow_starters?: components["schemas"]["PrincipalURN_or_all_authenticated_users"][];
+            /** @description The set of Principal URN values of users who may perform
+             *     administrative operations, including updating the
+             *     description itself. Only calling users with the
+             *     "administrator" role will be provided this
+             *     list. Otherwise, the value will always be an empty list.
+             *      */
+            flow_administrators?: components["schemas"]["PrincipalURN"][];
+            /** @description The user with primary responsibility for the Flow. */
+            flow_owner?: components["schemas"]["PrincipalURN"];
+            /**
+             * Format: date-time
+             * @description A timezone-aware ISO8601 format string that represents the time at
+             *     which the Flow was created.
+             *
+             */
+            created_at?: string;
+            /**
+             * Format: date-time
+             * @description A timezone-aware ISO8601 format string that represents the time at
+             *     which the Flow was last updated.
+             *
+             */
+            updated_at?: string;
+            synchronous?: boolean;
+            /** @description True if the Flow supports the /log operation providing detailed
+             *     information on the intermediate states of a Flow invocation.
+             *      */
+            log_supported?: boolean;
+            types?: ("Action" | "Event")[];
+            /** @enum {string} */
+            api_version?: "1.0";
+            /** @description A non-unique, human-friendly name used for displaying the Flow
+             *     to end users.
+             *      */
+            title?: string;
+            /** @description A concise summary of the Flow's purpose. */
+            subtitle?: string;
+            /** @description A detailed description of the Flow for end user display. */
+            description?: string;
+            /** @description A set of terms used to categorize the Flow which may be used in
+             *     query and discovery operations.
+             *      */
+            keywords?: string[];
+            /** @description The Flow's identity in Globus Auth. */
+            principal_urn?: components["schemas"]["PrincipalURN"];
+            /** @description The Flow's Globus Auth username. */
+            globus_auth_username?: string;
+            /**
+             * Format: uri
+             * @description The web-addressable location at which this Flow can be referenced
+             *     and run from.
+             *
+             */
+            flow_url?: string;
+            /**
+             * Format: uuid
+             * @description A subscription_id associated with this Flow. If no
+             *     subscription_id is present, the Flow may be
+             *     accepted, but may have limits on how long or how
+             *     much it can be used.
+             *
+             */
+            subscription_id?: string;
+        };
+        FlowValidationResponse: {
+            /** @description A mapping of RunAs values to the scopes required to run the flow
+             *     as that identity.
+             *      */
+            scopes?: components["schemas"]["FlowScopes"];
+        };
+        FlowValidationErrorResponse: {
+            /** @description A unique identifier for the validation error, used for debugging.
+             *      */
+            debug_id: string;
+            error: {
+                /** @description A readable keyword describing the failure. */
+                code: string;
+                /** An array of failure objects, describing what failed. */
+                detail: string | components["schemas"]["LocationErrorList"];
+                /** @description A human-readable message providing more context about the failure. */
+                message?: string;
+            };
+        };
+        LocationErrorList: {
+            /** The path of object keys that led to the validation failure. */
+            loc: string[];
+            /** A readable description of the validation failure. */
+            msg: string;
+            /** A readable failure category. */
+            type: string;
+        }[];
+        FlowScopes: {
+            [key: string]: string[];
+        };
+        BatchRunUpdateOperation: {
+            tags?: string[];
+            run_managers?: components["schemas"]["PrincipalURN"][];
+            run_monitors?: components["schemas"]["PrincipalURN"][];
+        };
+        BatchRunUpdateSetOperation: {
+            tags?: string[];
+            run_managers?: components["schemas"]["PrincipalURN"][];
+            run_monitors?: components["schemas"]["PrincipalURN"][];
+            /** @enum {string} */
+            status?: "cancel";
+        };
+        /** @description The requested operation was accepted.
+         *
+         *     The operation may have been completed, or may be completed at a later time.
+         *     A follow-up API request may be needed to confirm the status of the operation.
+         *      */
+        HTTP202Response: unknown;
+        /** @description The requesting user is not authorized to make the requested changes. */
+        HTTP403Response: unknown;
+        /** @description The input document failed input validation in some way. */
+        HTTP422Response: unknown;
+        /**
+         * @description A URN representation of an Identity in Globus either of a user from
+         *     Globus Auth or a group from Globus Groups or the special value
+         *     "public".
+         *
+         * @example urn:globus:groups:id:fdb38a24-03c1-11e3-86f7-12313809f035
+         */
+        PrincipalURN_or_public: string;
+        /**
+         * @description A URN representation of an Identity in Globus either of a user from
+         *     Globus Auth or a group from Globus Groups or the special value
+         *     "all_authenticated_users" indicating any user who presents valid
+         *     credentials (bearer token).
+         *
+         * @example all_authenticated_users
+         */
+        PrincipalURN_or_all_authenticated_users: string;
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export type operations = Record<string, never>;
+//# sourceMappingURL=flows.d.ts.map