reference.md

Reference

Comments

client.comments.list({ ...params }) -> IcePanel.CommentsListResponse

🔌 Usage

await client.comments.list({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.CommentsListRequest

requestOptions: CommentsClient.RequestOptions

client.comments.create({ ...params }) -> IcePanel.CommentsCreateResponse

🔌 Usage

await client.comments.create({
    landscapeId: "landscapeId",
    versionId: "versionId",
    body: {
        body: {
            content: "content",
            status: "open",
            type: "question"
        }
    }
});

⚙️ Parameters

request: IcePanel.CommentCreateRequest

requestOptions: CommentsClient.RequestOptions

client.comments.get({ ...params }) -> IcePanel.CommentsGetResponse

🔌 Usage

await client.comments.get({
    landscapeId: "landscapeId",
    versionId: "versionId",
    commentId: "commentId"
});

⚙️ Parameters

request: IcePanel.CommentFindRequest

requestOptions: CommentsClient.RequestOptions

client.comments.upsert({ ...params }) -> IcePanel.CommentsUpsertResponse

🔌 Usage

await client.comments.upsert({
    landscapeId: "landscapeId",
    versionId: "versionId",
    commentId: "commentId",
    body: {
        body: {
            content: "content",
            status: "open",
            type: "question"
        }
    }
});

⚙️ Parameters

request: IcePanel.CommentUpsertRequest

requestOptions: CommentsClient.RequestOptions

client.comments.delete({ ...params }) -> IcePanel.CommentsDeleteResponse

🔌 Usage

await client.comments.delete({
    landscapeId: "landscapeId",
    versionId: "versionId",
    commentId: "commentId"
});

⚙️ Parameters

request: IcePanel.CommentDeleteRequest

requestOptions: CommentsClient.RequestOptions

client.comments.update({ ...params }) -> IcePanel.CommentsUpdateResponse

🔌 Usage

await client.comments.update({
    landscapeId: "landscapeId",
    versionId: "versionId",
    commentId: "commentId",
    body: {}
});

⚙️ Parameters

request: IcePanel.CommentUpdateRequest

requestOptions: CommentsClient.RequestOptions

Diagrams

client.diagrams.list({ ...params }) -> IcePanel.DiagramsListResponse

🔌 Usage

await client.diagrams.list({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.DiagramsListRequest

requestOptions: DiagramsClient.RequestOptions

client.diagrams.create({ ...params }) -> IcePanel.DiagramsCreateResponse

🔌 Usage

await client.diagrams.create({
    landscapeId: "landscapeId",
    versionId: "versionId",
    body: {
        index: 1.1,
        modelId: "modelId",
        name: "name",
        type: "app-diagram"
    }
});

⚙️ Parameters

request: IcePanel.DiagramCreateRequest

requestOptions: DiagramsClient.RequestOptions

client.diagrams.get({ ...params }) -> IcePanel.DiagramsGetResponse

🔌 Usage

await client.diagrams.get({
    landscapeId: "landscapeId",
    versionId: "versionId",
    diagramId: "diagramId"
});

⚙️ Parameters

request: IcePanel.DiagramFindRequest

requestOptions: DiagramsClient.RequestOptions

client.diagrams.upsert({ ...params }) -> IcePanel.DiagramsUpsertResponse

🔌 Usage

await client.diagrams.upsert({
    landscapeId: "landscapeId",
    versionId: "versionId",
    diagramId: "diagramId",
    body: {
        index: 1.1,
        modelId: "modelId",
        name: "name",
        type: "app-diagram"
    }
});

⚙️ Parameters

request: IcePanel.DiagramUpsertRequest

requestOptions: DiagramsClient.RequestOptions

client.diagrams.delete({ ...params }) -> IcePanel.DiagramsDeleteResponse

🔌 Usage

await client.diagrams.delete({
    landscapeId: "landscapeId",
    versionId: "versionId",
    diagramId: "diagramId"
});

⚙️ Parameters

request: IcePanel.DiagramDeleteRequest

requestOptions: DiagramsClient.RequestOptions

client.diagrams.update({ ...params }) -> IcePanel.DiagramsUpdateResponse

🔌 Usage

await client.diagrams.update({
    landscapeId: "landscapeId",
    versionId: "versionId",
    diagramId: "diagramId",
    body: {}
});

⚙️ Parameters

request: IcePanel.DiagramUpdateRequest

requestOptions: DiagramsClient.RequestOptions

client.diagrams.exists({ ...params }) -> Headers

🔌 Usage

await client.diagrams.exists({
    landscapeId: "landscapeId",
    versionId: "versionId",
    diagramId: "diagramId"
});

⚙️ Parameters

request: IcePanel.DiagramExistsRequest

requestOptions: DiagramsClient.RequestOptions

client.diagrams.listThumbnails({ ...params }) -> IcePanel.DiagramsListThumbnailsResponse

🔌 Usage

await client.diagrams.listThumbnails({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.DiagramThumbnailsListRequest

requestOptions: DiagramsClient.RequestOptions

client.diagrams.getThumbnail({ ...params }) -> IcePanel.DiagramsGetThumbnailResponse

🔌 Usage

await client.diagrams.getThumbnail({
    landscapeId: "landscapeId",
    versionId: "versionId",
    diagramId: "diagramId"
});

⚙️ Parameters

request: IcePanel.DiagramThumbnailGetRequest

requestOptions: DiagramsClient.RequestOptions

Domains

client.domains.list({ ...params }) -> IcePanel.DomainsListResponse

🔌 Usage

await client.domains.list({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.DomainsListRequest

requestOptions: DomainsClient.RequestOptions

client.domains.create({ ...params }) -> IcePanel.DomainsCreateResponse

🔌 Usage

await client.domains.create({
    landscapeId: "landscapeId",
    versionId: "versionId",
    body: {
        name: "name"
    }
});

⚙️ Parameters

request: IcePanel.DomainCreateRequest

requestOptions: DomainsClient.RequestOptions

client.domains.get({ ...params }) -> IcePanel.DomainsGetResponse

🔌 Usage

await client.domains.get({
    landscapeId: "landscapeId",
    versionId: "versionId",
    domainId: "domainId"
});

⚙️ Parameters

request: IcePanel.DomainFindRequest

requestOptions: DomainsClient.RequestOptions

client.domains.upsert({ ...params }) -> IcePanel.DomainsUpsertResponse

🔌 Usage

await client.domains.upsert({
    landscapeId: "landscapeId",
    versionId: "versionId",
    domainId: "domainId",
    body: {
        name: "name"
    }
});

⚙️ Parameters

request: IcePanel.DomainUpsertRequest

requestOptions: DomainsClient.RequestOptions

client.domains.delete({ ...params }) -> IcePanel.DomainsDeleteResponse

🔌 Usage

await client.domains.delete({
    landscapeId: "landscapeId",
    versionId: "versionId",
    domainId: "domainId"
});

⚙️ Parameters

request: IcePanel.DomainDeleteRequest

requestOptions: DomainsClient.RequestOptions

client.domains.update({ ...params }) -> IcePanel.DomainsUpdateResponse

🔌 Usage

await client.domains.update({
    landscapeId: "landscapeId",
    versionId: "versionId",
    domainId: "domainId",
    body: {}
});

⚙️ Parameters

request: IcePanel.DomainUpdateRequest

requestOptions: DomainsClient.RequestOptions

client.domains.exists({ ...params }) -> Headers

🔌 Usage

await client.domains.exists({
    landscapeId: "landscapeId",
    versionId: "versionId",
    domainId: "domainId"
});

⚙️ Parameters

request: IcePanel.DomainExistsRequest

requestOptions: DomainsClient.RequestOptions

Drafts

client.drafts.list({ ...params }) -> IcePanel.DraftsListResponse

🔌 Usage

await client.drafts.list({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.DraftsListRequest

requestOptions: DraftsClient.RequestOptions

client.drafts.create({ ...params }) -> IcePanel.DraftsCreateResponse

🔌 Usage

await client.drafts.create({
    landscapeId: "landscapeId",
    versionId: "versionId",
    body: {
        name: "name",
        status: "in-progress"
    }
});

⚙️ Parameters

request: IcePanel.DraftCreateRequest

requestOptions: DraftsClient.RequestOptions

client.drafts.get({ ...params }) -> IcePanel.DraftsGetResponse

🔌 Usage

await client.drafts.get({
    landscapeId: "landscapeId",
    versionId: "versionId",
    draftId: "draftId"
});

⚙️ Parameters

request: IcePanel.DraftFindRequest

requestOptions: DraftsClient.RequestOptions

client.drafts.upsert({ ...params }) -> IcePanel.DraftsUpsertResponse

🔌 Usage

await client.drafts.upsert({
    landscapeId: "landscapeId",
    versionId: "versionId",
    draftId: "draftId",
    body: {
        name: "name",
        status: "in-progress"
    }
});

⚙️ Parameters

request: IcePanel.DraftUpsertRequest

requestOptions: DraftsClient.RequestOptions

client.drafts.delete({ ...params }) -> Record

🔌 Usage

await client.drafts.delete({
    landscapeId: "landscapeId",
    versionId: "versionId",
    draftId: "draftId"
});

⚙️ Parameters

request: IcePanel.DraftDeleteRequest

requestOptions: DraftsClient.RequestOptions

client.drafts.update({ ...params }) -> IcePanel.DraftsUpdateResponse

🔌 Usage

await client.drafts.update({
    landscapeId: "landscapeId",
    versionId: "versionId",
    draftId: "draftId",
    body: {}
});

⚙️ Parameters

request: IcePanel.DraftUpdateRequest

requestOptions: DraftsClient.RequestOptions

client.drafts.merge({ ...params }) -> IcePanel.DraftsMergeResponse

🔌 Usage

await client.drafts.merge({
    landscapeId: "landscapeId",
    versionId: "versionId",
    draftId: "draftId"
});

⚙️ Parameters

request: IcePanel.DraftMergeRequest

requestOptions: DraftsClient.RequestOptions

Flows

client.flows.list({ ...params }) -> IcePanel.FlowsListResponse

🔌 Usage

await client.flows.list({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.FlowsListRequest

requestOptions: FlowsClient.RequestOptions

client.flows.create({ ...params }) -> IcePanel.FlowsCreateResponse

🔌 Usage

await client.flows.create({
    landscapeId: "landscapeId",
    versionId: "versionId",
    body: {
        name: "name",
        diagramId: "diagramId"
    }
});

⚙️ Parameters

request: IcePanel.FlowCreateRequest

requestOptions: FlowsClient.RequestOptions

client.flows.get({ ...params }) -> IcePanel.FlowsGetResponse

🔌 Usage

await client.flows.get({
    landscapeId: "landscapeId",
    versionId: "versionId",
    flowId: "flowId"
});

⚙️ Parameters

request: IcePanel.FlowFindRequest

requestOptions: FlowsClient.RequestOptions

client.flows.upsert({ ...params }) -> IcePanel.FlowsUpsertResponse

🔌 Usage

await client.flows.upsert({
    landscapeId: "landscapeId",
    versionId: "versionId",
    flowId: "flowId",
    body: {
        name: "name",
        diagramId: "diagramId"
    }
});

⚙️ Parameters

request: IcePanel.FlowUpsertRequest

requestOptions: FlowsClient.RequestOptions

client.flows.delete({ ...params }) -> IcePanel.FlowsDeleteResponse

🔌 Usage

await client.flows.delete({
    landscapeId: "landscapeId",
    versionId: "versionId",
    flowId: "flowId"
});

⚙️ Parameters

request: IcePanel.FlowDeleteRequest

requestOptions: FlowsClient.RequestOptions

client.flows.update({ ...params }) -> IcePanel.FlowsUpdateResponse

🔌 Usage

await client.flows.update({
    landscapeId: "landscapeId",
    versionId: "versionId",
    flowId: "flowId",
    body: {}
});

⚙️ Parameters

request: IcePanel.FlowUpdateRequest

requestOptions: FlowsClient.RequestOptions

client.flows.exists({ ...params }) -> Headers

🔌 Usage

await client.flows.exists({
    landscapeId: "landscapeId",
    versionId: "versionId",
    flowId: "flowId"
});

⚙️ Parameters

request: IcePanel.FlowExistsRequest

requestOptions: FlowsClient.RequestOptions

client.flows.listThumbnails({ ...params }) -> IcePanel.FlowsListThumbnailsResponse

🔌 Usage

await client.flows.listThumbnails({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.FlowThumbnailsListRequest

requestOptions: FlowsClient.RequestOptions

client.flows.getThumbnail({ ...params }) -> IcePanel.FlowsGetThumbnailResponse

🔌 Usage

await client.flows.getThumbnail({
    landscapeId: "landscapeId",
    versionId: "versionId",
    flowId: "flowId"
});

⚙️ Parameters

request: IcePanel.FlowThumbnailGetRequest

requestOptions: FlowsClient.RequestOptions

Landscapes

client.landscapes.get({ ...params }) -> IcePanel.LandscapesGetResponse

🔌 Usage

await client.landscapes.get({
    landscapeId: "landscapeId"
});

⚙️ Parameters

request: IcePanel.LandscapeFindRequest

requestOptions: LandscapesClient.RequestOptions

client.landscapes.delete({ ...params }) -> Record

🔌 Usage

await client.landscapes.delete({
    landscapeId: "landscapeId"
});

⚙️ Parameters

request: IcePanel.LandscapeDeleteRequest

requestOptions: LandscapesClient.RequestOptions

client.landscapes.update({ ...params }) -> IcePanel.LandscapesUpdateResponse

🔌 Usage

await client.landscapes.update({
    landscapeId: "landscapeId",
    body: {}
});

⚙️ Parameters

request: IcePanel.LandscapeUpdateRequest

requestOptions: LandscapesClient.RequestOptions

client.landscapes.duplicate({ ...params }) -> IcePanel.LandscapesDuplicateResponse

🔌 Usage

await client.landscapes.duplicate({
    landscapeId: "landscapeId",
    body: {
        name: "name"
    }
});

⚙️ Parameters

request: IcePanel.LandscapeDuplicateRequest

requestOptions: LandscapesClient.RequestOptions

client.landscapes.copy({ ...params }) -> Record

🔌 Usage

await client.landscapes.copy({
    landscapeId: "landscapeId",
    targetLandscapeId: "targetLandscapeId"
});

⚙️ Parameters

request: IcePanel.LandscapeCopyRequest

requestOptions: LandscapesClient.RequestOptions

client.landscapes.search({ ...params }) -> IcePanel.LandscapesSearchResponse

📝 Description

Search the entire landscape

🔌 Usage

await client.landscapes.search({
    landscapeId: "landscapeId",
    versionId: "versionId",
    search: "search"
});

⚙️ Parameters

request: IcePanel.LandscapeSearchRequest

requestOptions: LandscapesClient.RequestOptions

Organizations

client.organizations.list({ ...params }) -> IcePanel.OrganizationsListResponse

🔌 Usage

await client.organizations.list();

⚙️ Parameters

request: IcePanel.OrganizationsListRequest

requestOptions: OrganizationsClient.RequestOptions

client.organizations.create({ ...params }) -> IcePanel.OrganizationsCreateResponse

🔌 Usage

await client.organizations.create({
    name: "name"
});

⚙️ Parameters

request: IcePanel.OrganizationRequired

requestOptions: OrganizationsClient.RequestOptions

client.organizations.get({ ...params }) -> IcePanel.OrganizationsGetResponse

🔌 Usage

await client.organizations.get({
    organizationId: "organizationId"
});

⚙️ Parameters

request: IcePanel.OrganizationFindRequest

requestOptions: OrganizationsClient.RequestOptions

client.organizations.delete({ ...params }) -> Record

🔌 Usage

await client.organizations.delete({
    organizationId: "organizationId"
});

⚙️ Parameters

request: IcePanel.OrganizationDeleteRequest

requestOptions: OrganizationsClient.RequestOptions

client.organizations.update({ ...params }) -> IcePanel.OrganizationsUpdateResponse

🔌 Usage

await client.organizations.update({
    organizationId: "organizationId",
    body: {}
});

⚙️ Parameters

request: IcePanel.OrganizationUpdateRequest

requestOptions: OrganizationsClient.RequestOptions

ShareLink

client.shareLink.get({ ...params }) -> IcePanel.ShareLinkGetResponse

🔌 Usage

await client.shareLink.get({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.ShareLinkFindRequest

requestOptions: ShareLinkClient.RequestOptions

client.shareLink.create({ ...params }) -> IcePanel.ShareLinkCreateResponse

🔌 Usage

await client.shareLink.create({
    landscapeId: "landscapeId",
    versionId: "versionId",
    body: {
        "protected": true
    }
});

⚙️ Parameters

request: IcePanel.ShareLinkCreateRequest

requestOptions: ShareLinkClient.RequestOptions

client.shareLink.delete({ ...params }) -> Record

🔌 Usage

await client.shareLink.delete({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.ShareLinkDeleteRequest

requestOptions: ShareLinkClient.RequestOptions

client.shareLink.update({ ...params }) -> IcePanel.ShareLinkUpdateResponse

🔌 Usage

await client.shareLink.update({
    landscapeId: "landscapeId",
    versionId: "versionId",
    body: {}
});

⚙️ Parameters

request: IcePanel.ShareLinkUpdateRequest

requestOptions: ShareLinkClient.RequestOptions

Tags

client.tags.list({ ...params }) -> IcePanel.TagsListResponse

🔌 Usage

await client.tags.list({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.TagsListRequest

requestOptions: TagsClient.RequestOptions

client.tags.create({ ...params }) -> IcePanel.TagsCreateResponse

🔌 Usage

await client.tags.create({
    landscapeId: "landscapeId",
    versionId: "versionId",
    body: {
        color: "blue",
        groupId: "groupId",
        index: 1.1,
        name: "name"
    }
});

⚙️ Parameters

request: IcePanel.TagCreateRequest

requestOptions: TagsClient.RequestOptions

client.tags.get({ ...params }) -> IcePanel.TagsGetResponse

🔌 Usage

await client.tags.get({
    landscapeId: "landscapeId",
    versionId: "versionId",
    tagId: "tagId"
});

⚙️ Parameters

request: IcePanel.TagFindRequest

requestOptions: TagsClient.RequestOptions

client.tags.upsert({ ...params }) -> IcePanel.TagsUpsertResponse

🔌 Usage

await client.tags.upsert({
    landscapeId: "landscapeId",
    versionId: "versionId",
    tagId: "tagId",
    body: {
        color: "blue",
        groupId: "groupId",
        index: 1.1,
        name: "name"
    }
});

⚙️ Parameters

request: IcePanel.TagUpsertRequest

requestOptions: TagsClient.RequestOptions

client.tags.delete({ ...params }) -> IcePanel.TagsDeleteResponse

🔌 Usage

await client.tags.delete({
    landscapeId: "landscapeId",
    versionId: "versionId",
    tagId: "tagId"
});

⚙️ Parameters

request: IcePanel.TagDeleteRequest

requestOptions: TagsClient.RequestOptions

client.tags.update({ ...params }) -> IcePanel.TagsUpdateResponse

🔌 Usage

await client.tags.update({
    landscapeId: "landscapeId",
    versionId: "versionId",
    tagId: "tagId",
    body: {}
});

⚙️ Parameters

request: IcePanel.TagUpdateRequest

requestOptions: TagsClient.RequestOptions

Teams

client.teams.list({ ...params }) -> IcePanel.TeamsListResponse

🔌 Usage

await client.teams.list({
    organizationId: "organizationId"
});

⚙️ Parameters

request: IcePanel.TeamsListRequest

requestOptions: TeamsClient.RequestOptions

client.teams.create({ ...params }) -> IcePanel.TeamsCreateResponse

🔌 Usage

await client.teams.create({
    organizationId: "organizationId",
    body: {
        name: "name"
    }
});

⚙️ Parameters

request: IcePanel.TeamCreateRequest

requestOptions: TeamsClient.RequestOptions

client.teams.get({ ...params }) -> IcePanel.TeamsGetResponse

🔌 Usage

await client.teams.get({
    organizationId: "organizationId",
    teamId: "teamId"
});

⚙️ Parameters

request: IcePanel.TeamFindRequest

requestOptions: TeamsClient.RequestOptions

client.teams.delete({ ...params }) -> Record

🔌 Usage

await client.teams.delete({
    organizationId: "organizationId",
    teamId: "teamId"
});

⚙️ Parameters

request: IcePanel.TeamDeleteRequest

requestOptions: TeamsClient.RequestOptions

client.teams.update({ ...params }) -> IcePanel.TeamsUpdateResponse

🔌 Usage

await client.teams.update({
    organizationId: "organizationId",
    teamId: "teamId",
    body: {}
});

⚙️ Parameters

request: IcePanel.TeamUpdateRequest

requestOptions: TeamsClient.RequestOptions

client.teams.listLandscapes({ ...params }) -> IcePanel.TeamsListLandscapesResponse

🔌 Usage

await client.teams.listLandscapes({
    organizationId: "organizationId",
    teamId: "teamId"
});

⚙️ Parameters

request: IcePanel.TeamLandscapesListRequest

requestOptions: TeamsClient.RequestOptions

client.teams.listModelObjects({ ...params }) -> IcePanel.TeamsListModelObjectsResponse

🔌 Usage

await client.teams.listModelObjects({
    organizationId: "organizationId",
    teamId: "teamId"
});

⚙️ Parameters

request: IcePanel.TeamModelObjectsListRequest

requestOptions: TeamsClient.RequestOptions

Versions

client.versions.list({ ...params }) -> IcePanel.VersionsListResponse

🔌 Usage

await client.versions.list({
    landscapeId: "landscapeId"
});

⚙️ Parameters

request: IcePanel.VersionsListRequest

requestOptions: VersionsClient.RequestOptions

client.versions.create({ ...params }) -> IcePanel.VersionsCreateResponse

🔌 Usage

await client.versions.create({
    landscapeId: "landscapeId",
    body: {
        name: "name",
        notes: "notes"
    }
});

⚙️ Parameters

request: IcePanel.VersionCreateRequest

requestOptions: VersionsClient.RequestOptions

client.versions.get({ ...params }) -> IcePanel.VersionsGetResponse

🔌 Usage

await client.versions.get({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.VersionFindRequest

requestOptions: VersionsClient.RequestOptions

client.versions.delete({ ...params }) -> unknown

🔌 Usage

await client.versions.delete({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.VersionDeleteRequest

requestOptions: VersionsClient.RequestOptions

client.versions.update({ ...params }) -> IcePanel.VersionsUpdateResponse

🔌 Usage

await client.versions.update({
    landscapeId: "landscapeId",
    versionId: "versionId",
    body: {}
});

⚙️ Parameters

request: IcePanel.VersionUpdateRequest

requestOptions: VersionsClient.RequestOptions

Catalog Technologies

client.catalog.technologies.createSignedIconUrl() -> IcePanel.TechnologiesCreateSignedIconUrlResponse

📝 Description

Create a signed URL prefix with access to all catalog icons

🔌 Usage

await client.catalog.technologies.createSignedIconUrl();

⚙️ Parameters

requestOptions: TechnologiesClient.RequestOptions

client.catalog.technologies.get({ ...params }) -> IcePanel.TechnologiesGetResponse

📝 Description

Find a technology

🔌 Usage

await client.catalog.technologies.get({
    catalogTechnologyId: "catalogTechnologyId"
});

⚙️ Parameters

request: IcePanel.CatalogTechnologyFindRequest

requestOptions: TechnologiesClient.RequestOptions

Comments Replies

client.comments.replies.list({ ...params }) -> IcePanel.RepliesListResponse

📝 Description

List comment replies

🔌 Usage

await client.comments.replies.list({
    landscapeId: "landscapeId",
    versionId: "versionId",
    commentId: "commentId"
});

⚙️ Parameters

request: IcePanel.CommentRepliesListRequest

requestOptions: RepliesClient.RequestOptions

client.comments.replies.create({ ...params }) -> IcePanel.RepliesCreateResponse

📝 Description

Create a comment reply

🔌 Usage

await client.comments.replies.create({
    landscapeId: "landscapeId",
    versionId: "versionId",
    commentId: "commentId",
    body: {
        content: "content"
    }
});

⚙️ Parameters

request: IcePanel.CommentReplyCreateRequest

requestOptions: RepliesClient.RequestOptions

client.comments.replies.get({ ...params }) -> IcePanel.RepliesGetResponse

📝 Description

Find a comment reply

🔌 Usage

await client.comments.replies.get({
    landscapeId: "landscapeId",
    versionId: "versionId",
    commentId: "commentId",
    commentReplyId: "commentReplyId"
});

⚙️ Parameters

request: IcePanel.CommentReplyFindRequest

requestOptions: RepliesClient.RequestOptions

client.comments.replies.upsert({ ...params }) -> IcePanel.RepliesUpsertResponse

🔌 Usage

await client.comments.replies.upsert({
    landscapeId: "landscapeId",
    versionId: "versionId",
    commentId: "commentId",
    commentReplyId: "commentReplyId",
    body: {
        content: "content"
    }
});

⚙️ Parameters

request: IcePanel.CommentReplyUpsertRequest

requestOptions: RepliesClient.RequestOptions

client.comments.replies.delete({ ...params }) -> Record

📝 Description

Delete a comment reply

🔌 Usage

await client.comments.replies.delete({
    landscapeId: "landscapeId",
    versionId: "versionId",
    commentId: "commentId",
    commentReplyId: "commentReplyId"
});

⚙️ Parameters

request: IcePanel.CommentReplyDeleteRequest

requestOptions: RepliesClient.RequestOptions

client.comments.replies.update({ ...params }) -> IcePanel.RepliesUpdateResponse

📝 Description

Update a comment reply

🔌 Usage

await client.comments.replies.update({
    landscapeId: "landscapeId",
    versionId: "versionId",
    commentId: "commentId",
    commentReplyId: "commentReplyId",
    body: {}
});

⚙️ Parameters

request: IcePanel.CommentReplyUpdateRequest

requestOptions: RepliesClient.RequestOptions

Diagrams Content

client.diagrams.content.get({ ...params }) -> IcePanel.ContentGetResponse

🔌 Usage

await client.diagrams.content.get({
    landscapeId: "landscapeId",
    versionId: "versionId",
    diagramId: "diagramId"
});

⚙️ Parameters

request: IcePanel.DiagramContentFindRequest

requestOptions: ContentClient.RequestOptions

client.diagrams.content.replace({ ...params }) -> IcePanel.ContentReplaceResponse

🔌 Usage

await client.diagrams.content.replace({
    landscapeId: "landscapeId",
    versionId: "versionId",
    diagramId: "diagramId",
    body: {}
});

⚙️ Parameters

request: IcePanel.DiagramContentReplaceRequest

requestOptions: ContentClient.RequestOptions

client.diagrams.content.update({ ...params }) -> IcePanel.ContentUpdateResponse

🔌 Usage

await client.diagrams.content.update({
    landscapeId: "landscapeId",
    versionId: "versionId",
    diagramId: "diagramId",
    body: {}
});

⚙️ Parameters

request: IcePanel.DiagramContentUpdateRequest

requestOptions: ContentClient.RequestOptions

Diagrams Groups

client.diagrams.groups.list({ ...params }) -> IcePanel.GroupsListResponse

🔌 Usage

await client.diagrams.groups.list({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.DiagramGroupsListRequest

requestOptions: GroupsClient.RequestOptions

client.diagrams.groups.create({ ...params }) -> IcePanel.GroupsCreateResponse

🔌 Usage

await client.diagrams.groups.create({
    landscapeId: "landscapeId",
    versionId: "versionId",
    body: {
        modelId: "modelId",
        name: "name"
    }
});

⚙️ Parameters

request: IcePanel.DiagramGroupCreateRequest

requestOptions: GroupsClient.RequestOptions

client.diagrams.groups.get({ ...params }) -> IcePanel.GroupsGetResponse

🔌 Usage

await client.diagrams.groups.get({
    landscapeId: "landscapeId",
    versionId: "versionId",
    diagramGroupId: "diagramGroupId"
});

⚙️ Parameters

request: IcePanel.DiagramGroupFindRequest

requestOptions: GroupsClient.RequestOptions

client.diagrams.groups.upsert({ ...params }) -> IcePanel.GroupsUpsertResponse

🔌 Usage

await client.diagrams.groups.upsert({
    landscapeId: "landscapeId",
    versionId: "versionId",
    diagramGroupId: "diagramGroupId",
    body: {
        modelId: "modelId",
        name: "name"
    }
});

⚙️ Parameters

request: IcePanel.DiagramGroupUpsertRequest

requestOptions: GroupsClient.RequestOptions

client.diagrams.groups.delete({ ...params }) -> IcePanel.GroupsDeleteResponse

🔌 Usage

await client.diagrams.groups.delete({
    landscapeId: "landscapeId",
    versionId: "versionId",
    diagramGroupId: "diagramGroupId"
});

⚙️ Parameters

request: IcePanel.DiagramGroupDeleteRequest

requestOptions: GroupsClient.RequestOptions

client.diagrams.groups.update({ ...params }) -> IcePanel.GroupsUpdateResponse

🔌 Usage

await client.diagrams.groups.update({
    landscapeId: "landscapeId",
    versionId: "versionId",
    diagramGroupId: "diagramGroupId",
    body: {}
});

⚙️ Parameters

request: IcePanel.DiagramGroupUpdateRequest

requestOptions: GroupsClient.RequestOptions

client.diagrams.groups.exists({ ...params }) -> Headers

🔌 Usage

await client.diagrams.groups.exists({
    landscapeId: "landscapeId",
    versionId: "versionId",
    diagramGroupId: "diagramGroupId"
});

⚙️ Parameters

request: IcePanel.DiagramGroupExistsRequest

requestOptions: GroupsClient.RequestOptions

Diagrams Export

client.diagrams.export.get({ ...params }) -> IcePanel.ExportGetResponse

🔌 Usage

await client.diagrams.export.get({
    landscapeId: "landscapeId",
    versionId: "versionId",
    diagramId: "diagramId",
    diagramExportImageId: "diagramExportImageId"
});

⚙️ Parameters

request: IcePanel.DiagramExportImageFindRequest

requestOptions: ExportClient.RequestOptions

client.diagrams.export.create({ ...params }) -> IcePanel.ExportCreateResponse

🔌 Usage

await client.diagrams.export.create({
    landscapeId: "landscapeId",
    versionId: "versionId",
    diagramId: "diagramId",
    body: {}
});

⚙️ Parameters

request: IcePanel.DiagramExportImageCreateRequest

requestOptions: ExportClient.RequestOptions

Flows Export

client.flows.export.text({ ...params }) -> string

🔌 Usage

await client.flows.export.text({
    landscapeId: "landscapeId",
    versionId: "versionId",
    flowId: "flowId"
});

⚙️ Parameters

request: IcePanel.FlowExportTextRequest

requestOptions: ExportClient.RequestOptions

client.flows.export.code({ ...params }) -> string

🔌 Usage

await client.flows.export.code({
    landscapeId: "landscapeId",
    versionId: "versionId",
    flowId: "flowId"
});

⚙️ Parameters

request: IcePanel.FlowExportCodeRequest

requestOptions: ExportClient.RequestOptions

client.flows.export.mermaid({ ...params }) -> string

🔌 Usage

await client.flows.export.mermaid({
    landscapeId: "landscapeId",
    versionId: "versionId",
    flowId: "flowId"
});

⚙️ Parameters

request: IcePanel.FlowExportMermaidRequest

requestOptions: ExportClient.RequestOptions

Landscapes Logs

client.landscapes.logs.list({ ...params }) -> IcePanel.LogsListResponse

📝 Description

List action logs

🔌 Usage

await client.landscapes.logs.list({
    landscapeId: "landscapeId"
});

⚙️ Parameters

request: IcePanel.ActionLogsListRequest

requestOptions: LogsClient.RequestOptions

client.landscapes.logs.get({ ...params }) -> IcePanel.LogsGetResponse

📝 Description

Find an action log

🔌 Usage

await client.landscapes.logs.get({
    landscapeId: "landscapeId",
    actionLogId: "actionLogId"
});

⚙️ Parameters

request: IcePanel.ActionLogFindRequest

requestOptions: LogsClient.RequestOptions

client.landscapes.logs.listChildren({ ...params }) -> IcePanel.LogsListChildrenResponse

📝 Description

List actions that happened as a result of a different action

🔌 Usage

await client.landscapes.logs.listChildren({
    landscapeId: "landscapeId",
    actionLogId: "actionLogId"
});

⚙️ Parameters

request: IcePanel.ActionLogChildrenListRequest

requestOptions: LogsClient.RequestOptions

Landscapes Export

client.landscapes.export.create({ ...params }) -> IcePanel.ExportCreateResponse

🔌 Usage

await client.landscapes.export.create({
    landscapeId: "landscapeId",
    versionId: "versionId",
    type: "pdf",
    body: {}
});

⚙️ Parameters

request: IcePanel.LandscapeExportRequest

requestOptions: ExportClient.RequestOptions

client.landscapes.export.get({ ...params }) -> IcePanel.ExportGetResponse

🔌 Usage

await client.landscapes.export.get({
    landscapeId: "landscapeId",
    versionId: "versionId",
    landscapeExportId: "landscapeExportId"
});

⚙️ Parameters

request: IcePanel.LandscapeExportFindRequest

requestOptions: ExportClient.RequestOptions

Landscapes Logs Stats

client.landscapes.logs.stats.byType({ ...params }) -> IcePanel.ActionLogStatsListByType

📝 Description

List total counts of actions for each action type (e.g. diagram-content-update, model-object-create)

🔌 Usage

await client.landscapes.logs.stats.byType({
    landscapeId: "landscapeId"
});

⚙️ Parameters

request: IcePanel.ActionLogStatsByTypeRequest

requestOptions: StatsClient.RequestOptions

client.landscapes.logs.stats.byEntity({ ...params }) -> IcePanel.ActionLogStatsListByEntity

📝 Description

List total counts of actions for each entity identifier

🔌 Usage

await client.landscapes.logs.stats.byEntity({
    landscapeId: "landscapeId"
});

⚙️ Parameters

request: IcePanel.ActionLogStatsByEntityRequest

requestOptions: StatsClient.RequestOptions

Model Connections

client.model.connections.list({ ...params }) -> IcePanel.ConnectionsListResponse

🔌 Usage

await client.model.connections.list({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.ModelConnectionsListRequest

requestOptions: ConnectionsClient.RequestOptions

client.model.connections.create({ ...params }) -> IcePanel.ConnectionsCreateResponse

🔌 Usage

await client.model.connections.create({
    landscapeId: "landscapeId",
    versionId: "versionId",
    body: {
        name: "name",
        originId: "originId",
        targetId: "targetId"
    }
});

⚙️ Parameters

request: IcePanel.ModelConnectionCreateRequest

requestOptions: ConnectionsClient.RequestOptions

client.model.connections.get({ ...params }) -> IcePanel.ConnectionsGetResponse

🔌 Usage

await client.model.connections.get({
    landscapeId: "landscapeId",
    versionId: "versionId",
    modelConnectionId: "modelConnectionId"
});

⚙️ Parameters

request: IcePanel.ModelConnectionFindRequest

requestOptions: ConnectionsClient.RequestOptions

client.model.connections.upsert({ ...params }) -> IcePanel.ConnectionsUpsertResponse

🔌 Usage

await client.model.connections.upsert({
    landscapeId: "landscapeId",
    versionId: "versionId",
    modelConnectionId: "modelConnectionId",
    body: {
        name: "name",
        originId: "originId",
        targetId: "targetId"
    }
});

⚙️ Parameters

request: IcePanel.ModelConnectionUpsertRequest

requestOptions: ConnectionsClient.RequestOptions

client.model.connections.delete({ ...params }) -> IcePanel.ConnectionsDeleteResponse

🔌 Usage

await client.model.connections.delete({
    landscapeId: "landscapeId",
    versionId: "versionId",
    modelConnectionId: "modelConnectionId"
});

⚙️ Parameters

request: IcePanel.ModelConnectionDeleteRequest

requestOptions: ConnectionsClient.RequestOptions

client.model.connections.update({ ...params }) -> IcePanel.ConnectionsUpdateResponse

🔌 Usage

await client.model.connections.update({
    landscapeId: "landscapeId",
    versionId: "versionId",
    modelConnectionId: "modelConnectionId",
    body: {}
});

⚙️ Parameters

request: IcePanel.ModelConnectionUpdateRequest

requestOptions: ConnectionsClient.RequestOptions

client.model.connections.generateDescription({ ...params }) -> IcePanel.ConnectionsGenerateDescriptionResponse

📝 Description

Generate a description for a model connection

🔌 Usage

await client.model.connections.generateDescription({
    landscapeId: "landscapeId",
    versionId: "versionId",
    modelConnectionId: "modelConnectionId",
    type: "caption"
});

⚙️ Parameters

request: IcePanel.ModelConnectionGenerateDescriptionRequest

requestOptions: ConnectionsClient.RequestOptions

Model Objects

client.model.objects.list({ ...params }) -> IcePanel.ObjectsListResponse

🔌 Usage

await client.model.objects.list({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.ModelObjectsListRequest

requestOptions: ObjectsClient.RequestOptions

client.model.objects.create({ ...params }) -> IcePanel.ObjectsCreateResponse

🔌 Usage

await client.model.objects.create({
    landscapeId: "landscapeId",
    versionId: "versionId",
    body: {
        name: "name",
        type: "actor"
    }
});

⚙️ Parameters

request: IcePanel.ModelObjectCreateRequest

requestOptions: ObjectsClient.RequestOptions

client.model.objects.get({ ...params }) -> IcePanel.ObjectsGetResponse

🔌 Usage

await client.model.objects.get({
    landscapeId: "landscapeId",
    versionId: "versionId",
    modelObjectId: "modelObjectId"
});

⚙️ Parameters

request: IcePanel.ModelObjectFindRequest

requestOptions: ObjectsClient.RequestOptions

client.model.objects.upsert({ ...params }) -> IcePanel.ObjectsUpsertResponse

🔌 Usage

await client.model.objects.upsert({
    landscapeId: "landscapeId",
    versionId: "versionId",
    modelObjectId: "modelObjectId",
    body: {
        name: "name",
        type: "actor"
    }
});

⚙️ Parameters

request: IcePanel.ModelObjectUpsertRequest

requestOptions: ObjectsClient.RequestOptions

client.model.objects.delete({ ...params }) -> IcePanel.ObjectsDeleteResponse

🔌 Usage

await client.model.objects.delete({
    landscapeId: "landscapeId",
    versionId: "versionId",
    modelObjectId: "modelObjectId"
});

⚙️ Parameters

request: IcePanel.ModelObjectDeleteRequest

requestOptions: ObjectsClient.RequestOptions

client.model.objects.update({ ...params }) -> IcePanel.ObjectsUpdateResponse

🔌 Usage

await client.model.objects.update({
    landscapeId: "landscapeId",
    versionId: "versionId",
    modelObjectId: "modelObjectId",
    body: {}
});

⚙️ Parameters

request: IcePanel.ModelObjectUpdateRequest

requestOptions: ObjectsClient.RequestOptions

Model Connections Export

client.model.connections.export.csv({ ...params }) -> string

🔌 Usage

await client.model.connections.export.csv({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.ModelConnectionsExportCsvRequest

requestOptions: ExportClient.RequestOptions

Model Objects Export

client.model.objects.export.dependenciesJson({ ...params }) -> IcePanel.ModelObjectDependenciesExport

📝 Description

Export object dependencies as JSON

🔌 Usage

await client.model.objects.export.dependenciesJson({
    landscapeId: "landscapeId",
    versionId: "versionId",
    modelObjectId: "modelObjectId"
});

⚙️ Parameters

request: IcePanel.ModelObjectDependenciesExportJsonRequest

requestOptions: ExportClient.RequestOptions

client.model.objects.export.csv({ ...params }) -> string

📝 Description

Export all model objects as CSV

🔌 Usage

await client.model.objects.export.csv({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.ModelObjectsExportCsvRequest

requestOptions: ExportClient.RequestOptions

Organizations Landscapes

client.organizations.landscapes.list({ ...params }) -> IcePanel.LandscapesListResponse

🔌 Usage

await client.organizations.landscapes.list({
    organizationId: "organizationId"
});

⚙️ Parameters

request: IcePanel.OrganizationLandscapesListRequest

requestOptions: LandscapesClient.RequestOptions

client.organizations.landscapes.create({ ...params }) -> IcePanel.LandscapesCreateResponse

🔌 Usage

await client.organizations.landscapes.create({
    organizationId: "organizationId",
    name: "name"
});

⚙️ Parameters

request: IcePanel.OrganizationLandscapeCreateRequest

requestOptions: LandscapesClient.RequestOptions

Organizations Logs

client.organizations.logs.list({ ...params }) -> IcePanel.LogsListResponse

📝 Description

List organization logs (only available on the scale plan and above)

🔌 Usage

await client.organizations.logs.list({
    organizationId: "organizationId"
});

⚙️ Parameters

request: IcePanel.OrganizationLogsListRequest

requestOptions: LogsClient.RequestOptions

client.organizations.logs.get({ ...params }) -> IcePanel.LogsGetResponse

📝 Description

Find an organization log (only available on the scale plan and above)

🔌 Usage

await client.organizations.logs.get({
    organizationId: "organizationId",
    organizationLogId: "organizationLogId"
});

⚙️ Parameters

request: IcePanel.OrganizationLogFindRequest

requestOptions: LogsClient.RequestOptions

Organizations Technologies

client.organizations.technologies.list({ ...params }) -> IcePanel.TechnologiesListResponse

🔌 Usage

await client.organizations.technologies.list({
    organizationId: "organizationId"
});

⚙️ Parameters

request: IcePanel.OrganizationTechnologiesListRequest

requestOptions: TechnologiesClient.RequestOptions

client.organizations.technologies.create({ ...params }) -> IcePanel.TechnologiesCreateResponse

🔌 Usage

await client.organizations.technologies.create({
    organizationId: "organizationId",
    body: {
        color: "blue",
        name: "name"
    }
});

⚙️ Parameters

request: IcePanel.OrganizationTechnologyCreateRequest

requestOptions: TechnologiesClient.RequestOptions

client.organizations.technologies.get({ ...params }) -> IcePanel.TechnologiesGetResponse

🔌 Usage

await client.organizations.technologies.get({
    organizationId: "organizationId",
    catalogTechnologyId: "catalogTechnologyId"
});

⚙️ Parameters

request: IcePanel.OrganizationTechnologyFindRequest

requestOptions: TechnologiesClient.RequestOptions

client.organizations.technologies.delete({ ...params }) -> Record

🔌 Usage

await client.organizations.technologies.delete({
    organizationId: "organizationId",
    catalogTechnologyId: "catalogTechnologyId"
});

⚙️ Parameters

request: IcePanel.OrganizationTechnologyDeleteRequest

requestOptions: TechnologiesClient.RequestOptions

client.organizations.technologies.update({ ...params }) -> IcePanel.TechnologiesUpdateResponse

🔌 Usage

await client.organizations.technologies.update({
    organizationId: "organizationId",
    catalogTechnologyId: "catalogTechnologyId",
    body: {}
});

⚙️ Parameters

request: IcePanel.OrganizationTechnologyUpdateRequest

requestOptions: TechnologiesClient.RequestOptions

Organizations Users

client.organizations.users.list({ ...params }) -> IcePanel.UsersListResponse

🔌 Usage

await client.organizations.users.list({
    organizationId: "organizationId"
});

⚙️ Parameters

request: IcePanel.OrganizationUsersListRequest

requestOptions: UsersClient.RequestOptions

client.organizations.users.delete({ ...params }) -> Record

🔌 Usage

await client.organizations.users.delete({
    organizationId: "organizationId",
    userId: "userId"
});

⚙️ Parameters

request: IcePanel.OrganizationUserDeleteRequest

requestOptions: UsersClient.RequestOptions

client.organizations.users.update({ ...params }) -> IcePanel.UsersUpdateResponse

🔌 Usage

await client.organizations.users.update({
    organizationId: "organizationId",
    userId: "userId",
    body: {
        permission: "billing"
    }
});

⚙️ Parameters

request: IcePanel.OrganizationUserUpdateRequest

requestOptions: UsersClient.RequestOptions

Organizations Logs Stats

client.organizations.logs.stats.byType({ ...params }) -> IcePanel.OrganizationLogStatsListByType

📝 Description

List total counts of actions for each action type (e.g. diagram-content-update, model-object-create)

🔌 Usage

await client.organizations.logs.stats.byType({
    organizationId: "organizationId"
});

⚙️ Parameters

request: IcePanel.OrganizationLogStatsByTypeRequest

requestOptions: StatsClient.RequestOptions

client.organizations.logs.stats.byEntity({ ...params }) -> IcePanel.ActionLogStatsListByEntity

📝 Description

List total counts of organizations for each entity identifier

🔌 Usage

await client.organizations.logs.stats.byEntity({
    organizationId: "organizationId"
});

⚙️ Parameters

request: IcePanel.OrganizationLogStatsByEntityRequest

requestOptions: StatsClient.RequestOptions

Organizations Users Invites

client.organizations.users.invites.list({ ...params }) -> IcePanel.InvitesListResponse

🔌 Usage

await client.organizations.users.invites.list({
    organizationId: "organizationId"
});

⚙️ Parameters

request: IcePanel.OrganizationUserInvitesListRequest

requestOptions: InvitesClient.RequestOptions

client.organizations.users.invites.create({ ...params }) -> IcePanel.InvitesCreateResponse

🔌 Usage

await client.organizations.users.invites.create({
    organizationId: "organizationId",
    body: {
        email: "email",
        expiresAt: "2024-01-15T09:30:00Z",
        permission: "billing"
    }
});

⚙️ Parameters

request: IcePanel.OrganizationUserInviteCreateRequest

requestOptions: InvitesClient.RequestOptions

client.organizations.users.invites.revoke({ ...params }) -> IcePanel.InvitesRevokeResponse

🔌 Usage

await client.organizations.users.invites.revoke({
    organizationId: "organizationId",
    organizationUserInviteId: "organizationUserInviteId"
});

⚙️ Parameters

request: IcePanel.OrganizationUserInviteRevokeRequest

requestOptions: InvitesClient.RequestOptions

Tags Groups

client.tags.groups.list({ ...params }) -> IcePanel.GroupsListResponse

🔌 Usage

await client.tags.groups.list({
    landscapeId: "landscapeId",
    versionId: "versionId"
});

⚙️ Parameters

request: IcePanel.TagGroupsListRequest

requestOptions: GroupsClient.RequestOptions

client.tags.groups.create({ ...params }) -> IcePanel.GroupsCreateResponse

🔌 Usage

await client.tags.groups.create({
    landscapeId: "landscapeId",
    versionId: "versionId",
    body: {
        icon: "bug",
        index: 1.1,
        name: "name"
    }
});

⚙️ Parameters

request: IcePanel.TagGroupCreateRequest

requestOptions: GroupsClient.RequestOptions

client.tags.groups.get({ ...params }) -> IcePanel.GroupsGetResponse

🔌 Usage

await client.tags.groups.get({
    landscapeId: "landscapeId",
    versionId: "versionId",
    tagGroupId: "tagGroupId"
});

⚙️ Parameters

request: IcePanel.TagGroupFindRequest

requestOptions: GroupsClient.RequestOptions

client.tags.groups.upsert({ ...params }) -> IcePanel.GroupsUpsertResponse

🔌 Usage

await client.tags.groups.upsert({
    landscapeId: "landscapeId",
    versionId: "versionId",
    tagGroupId: "tagGroupId",
    body: {
        icon: "bug",
        index: 1.1,
        name: "name"
    }
});

⚙️ Parameters

request: IcePanel.TagGroupUpsertRequest

requestOptions: GroupsClient.RequestOptions

client.tags.groups.delete({ ...params }) -> IcePanel.GroupsDeleteResponse

🔌 Usage

await client.tags.groups.delete({
    landscapeId: "landscapeId",
    versionId: "versionId",
    tagGroupId: "tagGroupId"
});

⚙️ Parameters

request: IcePanel.TagGroupDeleteRequest

requestOptions: GroupsClient.RequestOptions

client.tags.groups.update({ ...params }) -> IcePanel.GroupsUpdateResponse

🔌 Usage

await client.tags.groups.update({
    landscapeId: "landscapeId",
    versionId: "versionId",
    tagGroupId: "tagGroupId",
    body: {}
});

⚙️ Parameters

request: IcePanel.TagGroupUpdateRequest

requestOptions: GroupsClient.RequestOptions

Versions Reverts

client.versions.reverts.list({ ...params }) -> IcePanel.RevertsListResponse

🔌 Usage

await client.versions.reverts.list({
    landscapeId: "landscapeId"
});

⚙️ Parameters

request: IcePanel.VersionRevertsListRequest

requestOptions: RevertsClient.RequestOptions

client.versions.reverts.create({ ...params }) -> IcePanel.RevertsCreateResponse

🔌 Usage

await client.versions.reverts.create({
    landscapeId: "landscapeId",
    body: {
        notes: "notes",
        versionId: "versionId"
    }
});

⚙️ Parameters

request: IcePanel.VersionRevertCreateRequest

requestOptions: RevertsClient.RequestOptions

client.versions.reverts.get({ ...params }) -> IcePanel.RevertsGetResponse

🔌 Usage

await client.versions.reverts.get({
    landscapeId: "landscapeId",
    versionRevertId: "versionRevertId"
});

⚙️ Parameters

request: IcePanel.VersionRevertFindRequest

requestOptions: RevertsClient.RequestOptions

client.versions.reverts.update({ ...params }) -> IcePanel.RevertsUpdateResponse

🔌 Usage

await client.versions.reverts.update({
    landscapeId: "landscapeId",
    versionRevertId: "versionRevertId",
    body: {}
});

⚙️ Parameters

request: IcePanel.VersionRevertUpdateRequest

requestOptions: RevertsClient.RequestOptions