503 响应

我们的服务器返回的 HTTP 503 服务不可用 响应表示 API 访问流量出现意外高峰。服务器通常在接下来的五分钟内恢复正常运行。如果中断持续或您收到任何其他形式的 HTTP 5XX 错误，请联系支持。

身份验证

Postman 使用 API 密钥进行身份验证。API 密钥告知 API 服务器请求来自您。您在 Postman 中可以访问的一切都可以使用您的 API 密钥访问。您可以在 Postman 账户设置的 API 密钥 部分生成 Postman API 密钥。

您必须在每个对 Postman API 的请求中都包含 API 密钥，并在 X-Api-Key 请求头中指定。在 Postman 中，您可以将其存储为 环境变量。Postman API 集合 将使用它来执行 API 调用。

身份验证错误响应

如果 API 密钥缺失、格式错误或无效，您将收到 HTTP 401 未授权 响应代码。

将 API 密钥用作查询参数

接受 X-Api-Key 请求头的请求也接受当您将其作为 apikey 查询参数发送时。当您同时以请求头和查询参数的形式发送密钥时，作为头部分发的 API 密钥具有更高的优先级。

速率和用量限制

API 访问 速率限制 以每 API 密钥为单位，在单位时间内应用。限制是 每分钟 300 个请求。此外，根据您的 计划，您可能还有用量限制。如果您超过任一限制，您的请求将返回 HTTP 429 请求过多 状态代码。

当前速率限制窗口重置的时间，以 UTC 纪元秒为单位。

支持

• 有关访问 Postman API 的帮助，您可以访问 Postman 支持网站 或我们的 社区和支持网站。
• 联系 Postman 社区。
• 向 Postman 支持提交 帮助请求。

政策

• Postman 服务条款
• Postman 隐私政策

我们的服务器返回的 HTTP 503 服务不可用 响应表示 API 访问流量出现意外高峰。服务器通常在接下来的五分钟内恢复正常运行。如果中断持续或您收到任何其他形式的 HTTP 5XX 错误，请联系支持。

从 postman 获取API密钥

并将其传递给您的SDK

use postman_api::SidekoClient;
let client = SidekoClient::new(String::from("API_KEY")).unwrap();

delete_api

删除一个API。

let response = client.delete_api(DeleteApisApiIdRequest{
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
});

delete_schema_file

删除API模式中的文件。

let response = client.delete_schema_file(DeleteApisApiIdSchemasSchemaIdFilesFilePathRequest{
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
    schema_id: "5381f010-c4c1-11ed-afa1-0242ac120002".to_string(),
    file_path: "postman/collection/c1.json".to_string(),
});

delete_api_version

删除API版本。

注意

当API版本待发布时，此端点返回HTTP 404 Not Found 响应。

let response = client.delete_api_version(DeleteApisApiIdVersionsVersionIdRequest{
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
    version_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
});

delete_collection

删除一个集合。

let response = client.delete_collection(DeleteCollectionsCollectionIdRequest{
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
});

delete_collection_folder

删除集合中的文件夹。

let response = client.delete_collection_folder(DeleteCollectionsCollectionIdFoldersFolderIdRequest{
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
    folder_id: "65a99e60-8e0a-4b6e-b79c-7d8264cc5caa".to_string(),
});

delete_collection_request

删除集合中的请求。

let response = client.delete_collection_request(DeleteCollectionsCollectionIdRequestsRequestIdRequest{
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
    request_id: "c82dd02c-4870-4907-8fcb-593a876cf05b".to_string(),
});

delete_collection_response

删除集合中的响应。

let response = client.delete_collection_response(DeleteCollectionsCollectionIdResponsesResponseIdRequest{
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
    response_id: "cc364734-7dfd-4bfc-897d-be763dcdbb07".to_string(),
});

delete_environment

删除一个环境。

let response = client.delete_environment(DeleteEnvironmentsEnvironmentIdRequest{
    environment_id: "5daabc50-8451-43f6-922d-96b403b4f28e".to_string(),
});

delete_mock

删除一个模拟服务器。

let response = client.delete_mock(DeleteMocksMockIdRequest{
    mock_id: "e3d951bf-873f-49ac-a658-b2dcb91d3289".to_string(),
});

delete_mock_server_response

删除模拟服务器的服务器响应。

let response = client.delete_mock_server_response(DeleteMocksMockIdServerResponsesServerResponseIdRequest{
    mock_id: "e3d951bf-873f-49ac-a658-b2dcb91d3289".to_string(),
    server_response_id: "965cdd16-fe22-4d96-a161-3d05490ac421".to_string(),
});

unpublish_mock

取消发布模拟服务器。取消发布模拟服务器将将其 访问控制 配置设置为私有。

let response = client.unpublish_mock(DeleteMocksMockIdUnpublishRequest{
    mock_id: "e3d951bf-873f-49ac-a658-b2dcb91d3289".to_string(),
});

delete_monitor

删除一个监控器。

let response = client.delete_monitor(DeleteMonitorsMonitorIdRequest{
    monitor_id: "1e6b6cc1-c760-48e0-968f-4bfaeeae9af1".to_string(),
});

remove_element_or_folder

从您的 私有API网络 中删除一个元素或文件夹。

注意

删除API、集合或工作空间元素 不会 删除它。它只会将其从私有API网络文件夹中删除。

let response = client.remove_element_or_folder(DeleteNetworkPrivateElementTypeElementIdRequest{
    element_type: "api".to_string(),
    element_id: "5360b75f-447e-467c-9299-12fd6c92450d".to_string(),
});

delete_group

删除Postman中的组。

如果应用仅将删除的组分配给用户，则Postman中将禁用该删除组中的用户账户。

用户账户及其对应的数据 不会 被删除。要永久删除用户账户及其数据，请联系Postman支持。

let response = client.delete_group(DeleteScimV2GroupsGroupIdRequest{
    group_id: "405775fe15ed41872a8eea4c8aa2b38cda9749812cc55c99".to_string(),
});

delete_workspace

删除现有的工作空间。

重要

如果您删除了一个具有与其他工作空间链接的集合或环境的集合，这将删除所有工作空间中的集合和环境。

let response = client.delete_workspace(DeleteWorkspacesWorkspaceIdRequest{
    workspace_id: "1f0df51a-8658-4ee8-a2a1-d2567dfa09a9".to_string(),
});

get_all_apis

获取工作空间中所有API的信息。

注意

此端点仅返回Postman v10及以上版本创建或迁移的API。

let response = client.get_all_apis(GetApisRequest{
    workspace_id: "9a7bb368-c4c4-11ed-afa1-0242ac120002".to_string(),
    created_by: Some(12345678),
    cursor: Some("T1RBME5UQXo=".to_string()),
    description: Some("This is an API for testing purposes".to_string()),
    limit: Some(10),
});

get_an_api

获取API的信息。

注意

• Git连接的API将 仅 返回 versions 和 gitInfo 查询响应。这是因为模式和信息存储在连接的Git仓库中。 gitInfo 对象仅列出文件所在的仓库和文件夹位置。
• API查看器只能使用 versions 选项在 include 查询参数中。

let response = client.get_an_api(GetApisApiIdRequest{
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
    include: "schemas,collections",
});

get_collection

获取与API关联的集合。您可以使用 versionId 查询参数获取在版本中发布的集合。

注意

versionId 查询参数是API查看器的必需参数。

let response = client.get_collection(GetApisApiIdCollectionsCollectionIdRequest{
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
    collection_id: "12345678-61867bcc-c4c1-11ed-afa1-0242ac120002".to_string(),
    version_id: Some("12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string()),
});

get_schema

获取API模式的信息。您可以使用 versionId 查询参数获取在API版本中发布的模式。

您可以使用此API执行以下操作

• 获取模式元数据。
• 获取模式中的所有文件。这仅返回模式中的第一个文件。端点响应包含指向下一组响应结果的链接。
• 获取多文件或打包格式中的模式内容。

注意

versionId 查询参数是API查看器的 必需 参数。

let response = client.get_schema(GetApisApiIdSchemasSchemaIdRequest{
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
    schema_id: "5381f010-c4c1-11ed-afa1-0242ac120002".to_string(),
    bundled: Some(true),
    version_id: Some("12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string()),
});

get_schema_files

获取API模式中的文件。您可以使用 versionId 查询参数获取在API版本中发布的模式文件。

注意

versionId 查询参数是API查看器的必需参数。

let response = client.get_schema_files(GetApisApiIdSchemasSchemaIdFilesRequest{
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
    schema_id: "5381f010-c4c1-11ed-afa1-0242ac120002".to_string(),
    cursor: Some("T1RBME5UQXo=".to_string()),
    limit: Some(10),
    version_id: Some("12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string()),
});

get_schema_file_contents

获取定义路径处的API模式文件内容。您可以使用 versionId 查询参数获取在API版本中发布的模式文件内容。

注意

versionId 查询参数是API查看器的必需参数。

let response = client.get_schema_file_contents(GetApisApiIdSchemasSchemaIdFilesFilePathRequest{
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
    schema_id: "5381f010-c4c1-11ed-afa1-0242ac120002".to_string(),
    file_path: "postman/collection/c1.json".to_string(),
    version_id: Some("12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string()),
});

get_api_tags

获取与API关联的所有标签。

let response = client.get_api_tags(GetApisApiIdTagsRequest{
    api_id: "12345678-6fd634a3-79ba-451d-8f07-56a953f96667".to_string(),
});

get_status_of_an_async_task

获取异步任务的状态。

let response = client.get_status_of_an_async_task(GetApisApiIdTasksTaskIdRequest{
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
    task_id: "90ca9f5a-c4c4-21ed-afa1-0242ac120002".to_string(),
});

get_all_versions

获取API的所有已发布版本。

let response = client.get_all_versions(GetApisApiIdVersionsRequest{
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
    cursor: Some("T1RBME5UQXo=".to_string()),
    limit: Some(10),
});

get_api_version

获取API版本的详细信息。

注意

• 对于API编辑器，当版本状态为待定状态时，此端点返回HTTP 302 Found 状态码。同时，它还会返回 /apis/{apiId}/tasks/{taskId} 任务状态响应头。
• 对于API查看者，当版本状态为待定时，此端点返回HTTP 404 Not Found。

let response = client.get_api_version(GetApisApiIdVersionsVersionIdRequest{
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
    version_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
});

get_audit_logs

获取您团队生成的审计事件的列表。要获取所有审计事件的完整列表，请参阅我们的 利用审计日志 文档。

let response = client.get_audit_logs(GetAuditLogsRequest{
    cursor: Some("string".to_string()),
    limit: Some(123),
    order_by: Some("string".to_string()),
    since: Some("1970-01-01".to_string()),
    until: Some("1970-01-01".to_string()),
});

all_collections

获取您所有的 集合。响应包括您订阅的所有集合。

let response = client.all_collections(GetCollectionsRequest{
    name: Some("Test Collection".to_string()),
    workspace_id: Some("e361eeb4-00dd-4225-9774-6146a2555999".to_string()),
});

single_collection

获取集合的详细信息。要获取此端点可能值的完整列表，请使用 collection.json 架构文件。

let response = client.single_collection(GetCollectionsCollectionIdRequest{
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
    access_key: Some("PMAT-XXXXXXXXXXXXXXXXXXXXXXXXXX".to_string()),
});

get_collection_folder

获取集合中文件夹的详细信息。

let response = client.get_collection_folder(GetCollectionsCollectionIdFoldersFolderIdRequest{
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
    folder_id: "65a99e60-8e0a-4b6e-b79c-7d8264cc5caa".to_string(),
    ids: Some(true),
    populate: Some(true),
    uid: Some(true),
});

get_collection_request

获取集合中请求的详细信息。

let response = client.get_collection_request(GetCollectionsCollectionIdRequestsRequestIdRequest{
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
    request_id: "c82dd02c-4870-4907-8fcb-593a876cf05b".to_string(),
    ids: Some("string".to_string()),
    populate: Some(true),
    uid: Some(true),
});

get_collection_response

获取集合中响应的详细信息。

let response = client.get_collection_response(GetCollectionsCollectionIdResponsesResponseIdRequest{
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
    response_id: "cc364734-7dfd-4bfc-897d-be763dcdbb07".to_string(),
    ids: Some(true),
    populate: Some(true),
    uid: Some(true),
});

get_collection_tags

获取与集合关联的所有标签。

let response = client.get_collection_tags(GetCollectionsCollectionIdTagsRequest{
    collection_id: "12345678-12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
});

transform_collection_to_open_api

将现有的Postman集合转换为字符串化的OpenAPI定义。

注意

这 不会 创建API。

let response = client.transform_collection_to_open_api(GetCollectionsCollectionIdTransformationsRequest{
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
});

get_detected_secrets_locations

获取Postman 秘密扫描器检测到的秘密的位置。

let response = client.get_detected_secrets_locations(GetDetectedSecretsSecretIdLocationsRequest{
    secret_id: "ODk0MTU2".to_string(),
    workspace_id: "e361eeb4-00dd-4225-9774-6146a2555999".to_string(),
    cursor: Some("T1RBME5UQXo=".to_string()),
    limit: Some(10),
});

all_environments

获取您所有 环境 的信息。

let response = client.all_environments(GetEnvironmentsRequest{
    workspace_id: Some("e361eeb4-00dd-4225-9774-6146a2555999".to_string()),
});

single_environment

获取环境的信息。

let response = client.single_environment(GetEnvironmentsEnvironmentIdRequest{
    environment_id: "5daabc50-8451-43f6-922d-96b403b4f28e".to_string(),
});

api_key_owner

获取认证用户的信息。

注意

此API为具有 访客角色 的用户返回不同的响应。

let response = client.api_key_owner();

get_mocks

获取所有模拟服务器。默认情况下，此端点仅返回您在所有工作区中创建的模拟服务器。

注意

如果您传递了 teamId 和 workspace 查询参数，则此端点仅接受 workspace 查询。

let response = client.get_mocks(GetMocksRequest{
    team_id: Some("1b96f65f-8d23-4e1d-b5e2-055992c3b8cb".to_string()),
    workspace: Some("1f0df51a-8658-4ee8-a2a1-d2567dfa09a9".to_string()),
});

get_mock

获取模拟服务器的信息。

let response = client.get_mock(GetMocksMockIdRequest{
    mock_id: "e3d951bf-873f-49ac-a658-b2dcb91d3289".to_string(),
});

get_mock_call_logs

获取模拟服务器的调用日志。您可以在一次API调用中获取最多6.5MB的调用日志或总共100条调用日志，以先到达的限制为准。

调用日志包含发送到模拟服务器的请求和响应数据。日志提供了了解模拟服务器如何被使用的可见性。您可以将数据记录下来以进行调试、测试、分析等，具体取决于使用场景。

let response = client.get_mock_call_logs(GetMocksMockIdCallLogsRequest{
    mock_id: "e3d951bf-873f-49ac-a658-b2dcb91d3289".to_string(),
    cursor: Some("eyJzY2hlbWUiOiJjdXJzb3JfcGFnaW5hdGlvbklkIiwiZGlyZWN0aW9uVHlwZSI6Im5leHQiLCJwaXZvdCI6InBhZ2luYXRpb25JZCIsInZhbHVlIjoxNjQyNDAwMzU2MDAwNTc5fQ==".to_string()),
    direction: Some("asc".to_string()),
    include: Some("string".to_string()),
    limit: Some(3),
    request_method: Some("post".to_string()),
    request_path: Some("/animals?type=Dog".to_string()),
    response_status_code: Some(500),
    response_type: Some("success".to_string()),
    since: Some("2022-06-01T00:00:00.000Z".to_string()),
    sort: Some("updatedAt".to_string()),
    until: Some("2022-06-15T00:00:00.000Z".to_string()),
});

get_mock_server_responses

获取模拟服务器的所有服务器响应。

let response = client.get_mock_server_responses(GetMocksMockIdServerResponsesRequest{
    mock_id: "e3d951bf-873f-49ac-a658-b2dcb91d3289".to_string(),
});

get_mock_server_response

获取服务器响应的详细信息。

let response = client.get_mock_server_response(GetMocksMockIdServerResponsesServerResponseIdRequest{
    mock_id: "e3d951bf-873f-49ac-a658-b2dcb91d3289".to_string(),
    server_response_id: "965cdd16-fe22-4d96-a161-3d05490ac421".to_string(),
});

all_monitors

获取所有监控器。

let response = client.all_monitors(GetMonitorsRequest{
    workspace: Some("1e6b6cc1-c760-48e0-968f-4bfaeeae9af1".to_string()),
});

single_monitor

获取监控器的详细信息。

let response = client.single_monitor(GetMonitorsMonitorIdRequest{
    monitor_id: "1e6b6cc1-c760-48e0-968f-4bfaeeae9af1".to_string(),
});

get_all_elements_and_folders

获取添加到您的 私有API网络 的文件夹及其元素的信息。

注意

《limit》和《offset》参数分别应用于元素和文件夹。例如，如果您查询《limit》值为《10》和《offset》值为《0》，则端点返回10个元素和10个文件夹，共计20个项目。在《meta》响应中的《totalCount》属性是元素和文件夹的总数。

let response = client.get_all_elements_and_folders(GetNetworkPrivateRequest{
    added_by: Some(12345678),
    created_by: Some(12345678),
    description: Some("payments".to_string()),
    direction: Some("asc".to_string()),
    limit: Some(10),
    name: Some("billing".to_string()),
    offset: Some(5),
    parent_folder_id: Some(1),
    since: Some("2022-09-28T13:48:09.000Z".to_string()),
    sort: Some("updatedAt".to_string()),
    summary: Some("payments".to_string()),
    type_field: Some("api".to_string()),
    until: Some("2022-10-28T13:48:09.000Z".to_string()),
});

get_all_add_element_requests

获取添加元素到私有API网络的请求列表。

let response = client.get_all_add_element_requests(GetNetworkPrivateNetworkEntityRequestAllRequest{
    direction: Some("asc".to_string()),
    limit: Some(10),
    name: Some("Test api".to_string()),
    offset: Some(5),
    requested_by: Some(12345678),
    since: Some("2022-09-28T13:48:09.000Z".to_string()),
    sort: Some("updatedAt".to_string()),
    status: Some("pending".to_string()),
    type_field: Some("api".to_string()),
    until: Some("2022-10-28T13:48:09.000Z".to_string()),
});

fetch_all_group_resources

获取所有Postman团队成员的信息。

let response = client.fetch_all_group_resources(GetScimV2GroupsRequest{
    count: Some(2),
    filter: Some("displayName eq \"Test-API\"".to_string()),
    start_index: Some(1),
});

fetch_group_resource

获取团队中Postman组的信息。

let response = client.fetch_group_resource(GetScimV2GroupsGroupIdRequest{
    group_id: "405775fe15ed41872a8eea4c8aa2b38cda9749812cc55c99".to_string(),
});

get_resource_types

获取Postman SCIM API支持的所有资源类型。

let response = client.get_resource_types();

service_provider_config

获取Postman SCIM API配置信息。这包括支持的操作列表。

let response = client.service_provider_config();

fetch_all_user_resources

获取所有Postman团队成员的信息。

let response = client.fetch_all_user_resources(GetScimV2UsersRequest{
    count: Some(50),
    filter: Some("userName eq \"taylor-lee%40example.com\"".to_string()),
    start_index: Some(1),
});

fetch_user_resource

获取Postman团队成员的信息。

let response = client.fetch_user_resource(GetScimV2UsersUserIdRequest{
    user_id: "405775fe15ed41872a8eea4c8aa2b38cda9749812cc55c99".to_string(),
});

get_secret_types

获取Postman的秘密扫描器支持的秘密类型的元数据。您可以使用响应中的秘密类型ID，通过POST《/detected-secrets/{secretId}》端点查询数据。

let response = client.get_secret_types();

get_tagged_entities

通过给定的标签获取Postman元素（实体）。标签使您能够组织和搜索包含共享标签的工作区、API和集合。

注意

标签在Postman企业计划中可用。

let response = client.get_tagged_entities(GetTagsSlugEntitiesRequest{
    slug: "needs-review".to_string(),
    cursor: Some("eyJpZCI6ODYsImVudGl0eVR5cGUiOiJhcGkifQ==".to_string()),
    direction: Some("desc".to_string()),
    entity_type: Some("collection".to_string()),
    limit: Some(2),
});

all_workspaces

获取所有工作区。响应包括您的工作区和您有权访问的工作区。

注意

此端点的响应包含可见性字段。可见性决定了谁可以访问工作区

• personal — 只有您才能访问工作区。
• team — 所有团队成员都可以访问工作区。
• private — 只有受邀的团队成员可以访问工作区（《Professional和Enterprise计划仅限》）。
• public — 每个人都可以访问工作区。
• partner — 只有受邀的团队成员和合作伙伴可以访问工作区（《Enterprise Ultimate计划仅限》）。

let response = client.all_workspaces(GetWorkspacesRequest{
    type_field: Some("team".to_string()),
});

single_workspace

获取工作区信息。

注意

此端点的响应包含《visibility》字段。《可见性》决定了谁可以访问工作区

• personal — 只有您才能访问工作区。
• team — 所有团队成员都可以访问工作区。
• private — 只有受邀的团队成员可以访问工作区（《Professional和Enterprise计划仅限》）。
• public — 每个人都可以访问工作区。
• partner — 只有受邀的团队成员和合作伙伴可以访问工作区（《Enterprise Ultimate计划仅限》）。

重要

我们已废弃以下对象数组中的《name》和《uid》响应

• collections
• environments
• mocks
• monitors
• apis

let response = client.single_workspace(GetWorkspacesWorkspaceIdRequest{
    workspace_id: "1f0df51a-8658-4ee8-a2a1-d2567dfa09a9".to_string(),
});

get_workspace_global_variables

获取工作区的全局变量。

let response = client.get_workspace_global_variables(GetWorkspacesWorkspaceIdGlobalVariablesRequest{
    workspace_id: "1f0df51a-8658-4ee8-a2a1-d2567dfa09a9".to_string(),
});

get_workspace_tags

获取与工作区关联的所有标签。

let response = client.get_workspace_tags(GetWorkspacesWorkspaceIdTagsRequest{
    workspace_id: "1f0df51a-8658-4ee8-a2a1-d2567dfa09a9".to_string(),
});

patch_collection

更新特定集合信息，例如其名称、事件或其变量。有关 auth、variables 和 events 属性的更多信息，请参阅 collection.json 架构文件

• 有关 variables，请参阅 "#/definitions/variable"。
• 有关 auth，请参阅 "#/definitions/auth-attribute"。
• 有关 events，请参阅 "#/definitions/event"。

有关集合格式的更多信息，请参阅 Postman 集合格式文档。

let data_val = serde_json::json!({});
let data: PatchCollectionsCollectionIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.patch_collection(PatchCollectionsCollectionIdRequest{
    data,
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
});

patch_scim_v2_groups_group_id

更新组的信息。使用此端点，您可以

• 更新组的名称。
• 向 Postman 组添加或删除成员。

let data_val = serde_json::json!({});
let data: PatchScimV2GroupsGroupIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.patch_scim_v2_groups_group_id(PatchScimV2GroupsGroupIdRequest{
    data,
    group_id: "405775fe15ed41872a8eea4c8aa2b38cda9749812cc55c99".to_string(),
});

update_user_state

更新 Postman 中用户的活动状态。

重新激活用户

通过将 active 属性从 false 设置为 true，此操作将重新激活账户。这允许账户在 Postman 中进行身份验证并将账户添加回您的 Postman 团队。

let data_val = serde_json::json!({});
let data: PatchScimV2UsersUserIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.update_user_state(PatchScimV2UsersUserIdRequest{
    data,
    user_id: "405775fe15ed41872a8eea4c8aa2b38cda9749812cc55c99".to_string(),
});

create_api

创建 API。

let data_val = serde_json::json!({
  "name": "Test API"
});
let data: PostApisBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.create_api(PostApisRequest{
    data,
    workspace_id: "9a7bb368-c4c4-11ed-afa1-0242ac120002".to_string(),
});

add_collection

将集合添加到 API。为此，使用以下 operationType 值

• COPY_COLLECTION — 从工作区复制集合并将其添加到 API。
• CREATE_NEW — 通过提供新集合的内容创建新集合。
• GENERATE_FROM_SCHEMA — 从 API 架构生成集合。
  • options — 一个包含高级创建选项及其值的对象。您可以在 Postman 的 OpenAPI 3.0 到 Postman 集合 v2.1.0 转换器 OPTIONS 文档中找到属性及其值的完整列表。这些属性区分大小写。

let data = serde_json::json!({});

let response = client.add_collection(PostApisApiIdCollectionsRequest{
    data,
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
});

create_api_schema

为 API 创建一个架构。

let data_val = serde_json::json!({
  "files": [
    {}
  ],
  "type": "openapi:3"
});
let data: PostApisApiIdSchemasBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.create_api_schema(PostApisApiIdSchemasRequest{
    data,
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
});

create_api_version

异步创建新的 API 版本，并立即返回 HTTP 202 已接受 响应。响应包含在 Location 标头中的轮询链接到任务状态 API。

此端点相当于在 Postman 应用程序中发布版本，这是 API 集合和架构在特定时间点的快照。

let data = serde_json::json!({
  "collections": [
    {}
  ],
  "name": "v1",
  "schemas": [
    {}
  ]
});

let response = client.create_api_version(PostApisApiIdVersionsRequest{
    data,
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
});

create_collection

使用 Postman 集合 v2 架构格式 创建集合。

有关集合格式的更多信息，请参阅 Postman 集合格式文档。

注意

• 有关此端点可用属性的完整列表，请使用以下参考，可在 collection.json 架构文件 中找到
  • info 对象 — 使用 definitions.info 条目。
  • item 对象 — 使用 definitions.items 条目。
• 有关所有其他可能的值，请参阅 collection.json 架构文件。

let data_val = serde_json::json!({});
let data: PostCollectionsBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.create_collection(PostCollectionsRequest{
    data,
    workspace_id: Some("e361eeb4-00dd-4225-9774-6146a2555999".to_string()),
});

create_a_fork

从现有集合创建一个工作区中的 分支。

let data_val = serde_json::json!({
  "label": "Test Fork"
});
let data: PostCollectionsForkCollectionIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.create_a_fork(PostCollectionsForkCollectionIdRequest{
    data,
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
    workspace: "1f0df51a-8658-4ee8-a2a1-d2567dfa09a9".to_string(),
});

merge_a_fork

将分支集合合并回其目标集合。

let data_val = serde_json::json!({
  "destination": "12345678-12ece9e1-2abf-4edc-8e34-de66e74114d2",
  "source": "12345678-12ece9e1-2abf-4edc-8e34-de66e74114d2"
});
let data: PostCollectionsMergeBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.merge_a_fork(PostCollectionsMergeRequest{
    data,
});

create_collection_folder

在集合中创建一个文件夹。有关属性的完整列表，请参阅 collection.json 架构文件 中的“文件夹”部分。

您可以使用此端点将请求和响应导入到新建文件夹中。要这样做，请包含请求体中的requests字段和请求对象列表。有关更多信息，请参阅提供的示例。

注意

建议您在请求体中传递name属性。如果不传递，系统将使用空值。因此，这将创建一个空名称的文件夹。

let data_val = serde_json::json!({});
let data: PostCollectionsCollectionIdFoldersBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.create_collection_folder(PostCollectionsCollectionIdFoldersRequest{
    data,
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
});

create_collection_request

在集合中创建请求。有关属性列表的完整信息，请参阅集合格式请求文档。

注意

建议您在请求体中传递name属性。如果不传递，系统将使用空值。因此，这将创建一个空名称的请求。

let data_val = serde_json::json!({});
let data: PostCollectionsCollectionIdRequestsBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.create_collection_request(PostCollectionsCollectionIdRequestsRequest{
    data,
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
    folder_id: Some("string".to_string()),
});

create_collection_response

在集合中创建请求响应。有关属性列表的完整信息，请参阅集合格式响应文档。

注意

建议您在请求体中传递name属性。如果不传递，系统将使用空值。因此，这将创建一个空名称的响应。

let data_val = serde_json::json!({});
let data: PostCollectionsCollectionIdResponsesBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.create_collection_response(PostCollectionsCollectionIdResponsesRequest{
    data,
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
    request_id: "string".to_string(),
});

detected_secrets_queries

返回Postman的秘密扫描器检测到的所有秘密，按工作区分组。如果您传递一个空的请求体，则此端点返回所有结果。

let data_val = serde_json::json!({});
let data: PostDetectedSecretsQueriesBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.detected_secrets_queries(PostDetectedSecretsQueriesRequest{
    data,
    cursor: Some("T1RBME5UQXo=".to_string()),
    include: Some("meta.total".to_string()),
    limit: Some(10),
});

create_environment

创建环境。

let data_val = serde_json::json!({});
let data: PostEnvironmentsBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.create_environment(PostEnvironmentsRequest{
    data,
    workspace_id: Some("e361eeb4-00dd-4225-9774-6146a2555999".to_string()),
});

import_external_api_specification

将OpenAPI定义导入Postman作为新的Postman集合。

let data = serde_json::json!({});

let response = client.import_external_api_specification(PostImportOpenapiRequest{
    data,
    workspace_id: Some("e361eeb4-00dd-4225-9774-6146a2555999".to_string()),
});

create_mock

在Postman v10及以上版本中，您不能为添加到API定义中的集合创建模拟。

在集合中创建模拟服务器。

let data_val = serde_json::json!({});
let data: PostMocksBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.create_mock(PostMocksRequest{
    data,
    workspace_id: Some("1f0df51a-8658-4ee8-a2a1-d2567dfa09a9".to_string()),
});

publish_mock

发布模拟服务器。发布模拟服务器将它的访问控制配置设置为公开。

let response = client.publish_mock(PostMocksMockIdPublishRequest{
    mock_id: "e3d951bf-873f-49ac-a658-b2dcb91d3289".to_string(),
});

create_server_response

创建服务器响应。服务器响应允许您模拟5xx服务器级别响应，如500或503。

服务器级别响应与应用程序级别逻辑无关。服务器响应允许您在模拟服务器上模拟此行为。您不需要为模拟服务器上所有公开路径定义每个错误。

如果您将服务器响应设置为活动状态，则所有对模拟服务器的调用都将返回该活动服务器响应。

注意

您可以为模拟服务器创建多个服务器响应，但只能有一个模拟服务器被设置为活动状态。

let data_val = serde_json::json!({});
let data: PostMocksMockIdServerResponsesBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.create_server_response(PostMocksMockIdServerResponsesRequest{
    data,
    mock_id: "e3d951bf-873f-49ac-a658-b2dcb91d3289".to_string(),
});

create_monitor

在Postman v10及以上版本中，您不能为添加到API定义中的集合创建监视器。

创建监视器。

let data_val = serde_json::json!({});
let data: PostMonitorsBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.create_monitor(PostMonitorsRequest{
    data,
    workspace_id: Some("e361eeb4-00dd-4225-9774-6146a2555999".to_string()),
});

run_a_monitor

运行监视器并返回其运行结果。

let response = client.run_a_monitor(PostMonitorsMonitorIdRunRequest{
    monitor_id: "1e6b6cc1-c760-48e0-968f-4bfaeeae9af1".to_string(),
});

post_element_or_folder

在您的私有API网络中发布元素或创建文件夹。元素是Postman API、集合或工作区。

let data = serde_json::json!({});

let response = client.post_element_or_folder(PostNetworkPrivateRequest{
    data,
});

create_group

在Postman中创建新的用户组并为每个组成员创建新账户。

每个账户都将添加到您的Postman团队，并为每个用户激活认证。如果现有Postman账户使用的电子邮件与组成员的电子邮件ID匹配，则将为该用户发送电子邮件邀请加入您的Postman团队。一旦用户接受邀请，他们将被添加到您的团队。

默认情况下，系统将新用户分配为开发人员角色。您可以在Postman中更新用户角色。

let data_val = serde_json::json!({});
let data: PostScimV2GroupsBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.create_group(PostScimV2GroupsRequest{
    data,
});

create_user

在Postman中创建新的用户账户并将用户添加到您的组织的Postman团队。如果该账户不存在，这将同时激活用户，以便他们可以登录到您的Postman团队。

如果账户已存在，系统会向用户发送一个电子邮件邀请加入Postman团队。用户接受邀请后即可加入团队。

默认情况下，系统将新用户分配为开发人员角色。您可以在Postman中更新用户角色。

let data_val = serde_json::json!({});
let data: PostScimV2UsersBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.create_user(PostScimV2UsersRequest{
    data,
});

schema_security_validation

对给定的定义进行分析，并基于您的预定义规则集返回任何问题。此端点可以帮助您了解违规的影响，并提供解决任何错误的解决方案。您可以将此端点包含到CI/CD流程中以自动化模式验证。

有关更多信息，请参阅我们的API定义中的规则违规文档。

注意

• 定义的最大允许大小为10 MB。
• 您必须导入并启用Postman的OWASP安全规则，以便此端点返回任何安全规则违规。

let data_val = serde_json::json!({});
let data: PostSecurityApiValidationBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.schema_security_validation(PostSecurityApiValidationRequest{
    data,
});

create_webhook

创建一个触发自定义有效负载的webhook。您可以从端点响应中的webhookUrl属性获取webhook的URL。

let data_val = serde_json::json!({});
let data: PostWebhooksBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.create_webhook(PostWebhooksRequest{
    data,
    workspace_id: Some("e361eeb4-00dd-4225-9774-6146a2555999".to_string()),
});

create_workspace

创建一个新的工作区。

重要

我们已弃用在工作区之间链接集合或环境。我们不推荐这样做。

如果您有一个链接的集合或环境，请注意以下事项

• 端点不会创建集合或环境的克隆。
• 您对链接的集合或环境所做的任何更改都会在所有工作区中进行更改。
• 如果您删除了在工作区之间链接的集合或环境，系统将在所有工作区中删除它。

let data_val = serde_json::json!({});
let data: PostWorkspacesBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.create_workspace(PostWorkspacesRequest{
    data,
});

update_an_api

更新API。

let data_val = serde_json::json!({
  "name": "Test API"
});
let data: PutApisApiIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.update_an_api(PutApisApiIdRequest{
    data,
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
});

sync_collection_with_schema

将附加到API的集合与API模式同步。

这是一个异步端点，返回HTTP 202 已接受响应。响应包含一个轮询链接，该链接指向位于Location标题中的/apis/{apiId}/tasks/{taskId}端点。

注意

此端点仅支持OpenAPI 3模式类型。

let response = client.sync_collection_with_schema(PutApisApiIdCollectionsCollectionIdSyncWithSchemaTasksRequest{
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
    collection_id: "12345678-61867bcc-c4c1-11ed-afa1-0242ac120002".to_string(),
});

create_or_update_schema_file

创建或更新API模式文件。

注意

• 如果提供的文件路径存在，则将使用新内容更新该文件。
• 如果提供的文件路径不存在，则创建新的模式文件。
• 如果文件路径包含一个/（正斜杠）字符，则创建一个文件夹。例如，如果文件路径是dir/schema.json值，则创建一个包含schema.json文件的dir文件夹。

let data_val = serde_json::json!({
  "content": "string"
});
let data: PutApisApiIdSchemasSchemaIdFilesFilePathBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.create_or_update_schema_file(PutApisApiIdSchemasSchemaIdFilesFilePathRequest{
    data,
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
    schema_id: "5381f010-c4c1-11ed-afa1-0242ac120002".to_string(),
    file_path: "postman/collection/c1.json".to_string(),
});

update_api_tags

更新API的相关标签。此端点用您在请求正文中传递的标签替换所有现有标签。

let data_val = serde_json::json!({
  "tags": [
    {
      "slug": "needs-review"
    }
  ]
});
let data: PutApisApiIdTagsBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.update_api_tags(PutApisApiIdTagsRequest{
    data,
    api_id: "12345678-6fd634a3-79ba-451d-8f07-56a953f96667".to_string(),
});

update_api_version

更新API版本。

注意

当API版本待发布时，此端点返回HTTP 404 Not Found 响应。

let data_val = serde_json::json!({
  "name": "Release 1.5"
});
let data: PutApisApiIdVersionsVersionIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.update_api_version(PutApisApiIdVersionsVersionIdRequest{
    data,
    api_id: "90ca9f5a-c4c4-11ed-afa1-0242ac120002".to_string(),
    version_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
});

put_collection

使用Postman Collection v2模式格式替换集合的内容。在请求正文中包含集合的ID值。如果不包含这些值，则端点将删除现有项并创建新项。

有关此端点可用属性的完整列表，请使用以下参考，可在 collection.json 架构文件 中找到

• info对象 - 使用"#/definitions/info"。
• item 对象 — 使用 "#/definitions/item"。

对于所有其他可能的值，请参考 collection.json 架构文件。有关集合格式的更多信息，请参阅 Postman 集合格式文档。

注意

要将另一个集合的内容复制到指定的集合中，在通过此端点传递之前，请删除所有 ID 值。如果不这样做，此端点将返回错误。这些值包括 id、uid 和 postman_id 值。

let data_val = serde_json::json!({});
let data: PutCollectionsCollectionIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.put_collection(PutCollectionsCollectionIdRequest{
    data,
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
});

update_collection_folder

更新集合中的一个文件夹。有关属性的完整列表，请参阅 collection.json 架构文件中的“文件夹”。

注意

此端点的作用类似于 PATCH 方法。它只更新请求体中传递的值（例如，name 属性）。端点不会更新整个资源。

let data_val = serde_json::json!({});
let data: PutCollectionsCollectionIdFoldersFolderIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.update_collection_folder(PutCollectionsCollectionIdFoldersFolderIdRequest{
    data,
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
    folder_id: "65a99e60-8e0a-4b6e-b79c-7d8264cc5caa".to_string(),
});

update_collection_request

更新集合中的一个请求。有关属性的完整列表，请参阅 集合格式请求文档。

注意

• 在此端点中，您必须传递一个集合 ID（例如 12ece9e1-2abf-4edc-8e34-de66e74114d2），而不是集合（例如 12345678-12ece9e1-2abf-4edc-8e34-de66e74114d2）。
• 此端点不支持更改请求的文件夹。

let data_val = serde_json::json!({});
let data: PutCollectionsCollectionIdRequestsRequestIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.update_collection_request(PutCollectionsCollectionIdRequestsRequestIdRequest{
    data,
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
    request_id: "c82dd02c-4870-4907-8fcb-593a876cf05b".to_string(),
});

update_collection_response

更新集合中的一个响应。有关属性的完整列表，请参阅 集合格式响应文档。

注意

• 在此端点中，您必须传递一个集合 ID（例如 12ece9e1-2abf-4edc-8e34-de66e74114d2），而不是集合 UID（例如 12345678-12ece9e1-2abf-4edc-8e34-de66e74114d2）。
• 此端点的作用类似于 PATCH 方法。它只更新请求体中传递的值（例如，name 属性）。端点不会更新整个资源。

let data_val = serde_json::json!({});
let data: PutCollectionsCollectionIdResponsesResponseIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.update_collection_response(PutCollectionsCollectionIdResponsesResponseIdRequest{
    data,
    collection_id: "12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
    response_id: "cc364734-7dfd-4bfc-897d-be763dcdbb07".to_string(),
});

update_collection_tags

更新集合关联的标签。此端点将替换您在请求体中传递的所有现有标签。

let data_val = serde_json::json!({
  "tags": [
    {
      "slug": "needs-review"
    }
  ]
});
let data: PutCollectionsCollectionIdTagsBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.update_collection_tags(PutCollectionsCollectionIdTagsRequest{
    data,
    collection_id: "12345678-12ece9e1-2abf-4edc-8e34-de66e74114d2".to_string(),
});

update_detected_secret_resolutions

更新工作区中检测到的秘密的解析状态。

let data_val = serde_json::json!({
  "resolution": "ACCEPTED_RISK",
  "workspaceId": "e361eeb4-00dd-4225-9774-6146a2555999"
});
let data: PutDetectedSecretsSecretIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.update_detected_secret_resolutions(PutDetectedSecretsSecretIdRequest{
    data,
    secret_id: "ODk0MTU2".to_string(),
});

update_environment

更新环境。

let data_val = serde_json::json!({});
let data: PutEnvironmentsEnvironmentIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.update_environment(PutEnvironmentsEnvironmentIdRequest{
    data,
    environment_id: "5daabc50-8451-43f6-922d-96b403b4f28e".to_string(),
});

update_mock

更新模拟服务器。

let data_val = serde_json::json!({});
let data: PutMocksMockIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.update_mock(PutMocksMockIdRequest{
    data,
    mock_id: "e3d951bf-873f-49ac-a658-b2dcb91d3289".to_string(),
});

update_server_response

更新服务器响应。

let data_val = serde_json::json!({});
let data: PutMocksMockIdServerResponsesServerResponseIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.update_server_response(PutMocksMockIdServerResponsesServerResponseIdRequest{
    data,
    mock_id: "e3d951bf-873f-49ac-a658-b2dcb91d3289".to_string(),
    server_response_id: "965cdd16-fe22-4d96-a161-3d05490ac421".to_string(),
});

update_monitor

更新监控器。

let data_val = serde_json::json!({});
let data: PutMonitorsMonitorIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.update_monitor(PutMonitorsMonitorIdRequest{
    data,
    monitor_id: "1e6b6cc1-c760-48e0-968f-4bfaeeae9af1".to_string(),
});

respond_element_add_request

响应添加到 私有 API 网络 的请求。只有管理员可以批准或拒绝请求。一旦批准，元素将出现在团队的私有 API 网络中。

let data_val = serde_json::json!({
  "status": "denied"
});
let data: PutNetworkPrivateNetworkEntityRequestRequestIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.respond_element_add_request(PutNetworkPrivateNetworkEntityRequestRequestIdRequest{
    data,
    request_id: 232,
});

put_element_or_folder

更新您的 私有 API 网络 中的元素或文件夹。

let data = serde_json::json!({});

let response = client.put_element_or_folder(PutNetworkPrivateElementTypeElementIdRequest{
    data,
    element_type: "api".to_string(),
    element_id: "5360b75f-447e-467c-9299-12fd6c92450d".to_string(),
});

update_user_information

更新 Postman 中用户的姓名和姓氏。

注意

您只能使用 SCIM API 更新用户的姓名和姓氏。您无法使用 API 更新其他用户属性。

let data_val = serde_json::json!({});
let data: PutScimV2UsersUserIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.update_user_information(PutScimV2UsersUserIdRequest{
    data,
    user_id: "405775fe15ed41872a8eea4c8aa2b38cda9749812cc55c99".to_string(),
});

update_workspace

更新工作区。

重要

我们已弃用在工作区之间链接集合或环境。我们不推荐这样做。

如果您有一个链接的集合或环境，请注意以下事项

• 端点不会创建集合或环境的克隆。
• 您对链接的集合或环境所做的任何更改都会在所有工作区中进行更改。
• 如果您删除了在工作区之间链接的集合或环境，系统将在所有工作区中删除它。

let data_val = serde_json::json!({});
let data: PutWorkspacesWorkspaceIdBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.update_workspace(PutWorkspacesWorkspaceIdRequest{
    data,
    workspace_id: "1f0df51a-8658-4ee8-a2a1-d2567dfa09a9".to_string(),
});

put_workspace_global_variables

更新并替换工作区的全局 变量。此端点将替换所有现有的全局变量，用请求体中传递的变量替换。

let data_val = serde_json::json!({});
let data: PutWorkspacesWorkspaceIdGlobalVariablesBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.put_workspace_global_variables(PutWorkspacesWorkspaceIdGlobalVariablesRequest{
    data,
    workspace_id: "1f0df51a-8658-4ee8-a2a1-d2567dfa09a9".to_string(),
});

update_workspace_tags

更新工作区关联的标签。此端点将替换所有现有的标签，用请求体中传递的标签替换。

let data_val = serde_json::json!({
  "tags": [
    {
      "slug": "needs-review"
    }
  ]
});
let data: PutWorkspacesWorkspaceIdTagsBody = serde_json::from_value(data_val).expect("invalid json value");

let response = client.update_workspace_tags(PutWorkspacesWorkspaceIdTagsRequest{
    data,
    workspace_id: "1f0df51a-8658-4ee8-a2a1-d2567dfa09a9".to_string(),
});