Docs Packages
  1. Packages
  2. Port
  3. API Docs
  4. AggregationProperties
Port v2.0.1 published on Monday, May 13, 2024 by port-labs
port-labs/pulumi-port

port.AggregationProperties

Explore with Pulumi AI

port logo
Port v2.0.1 published on Monday, May 13, 2024 by port-labs
port-labs/pulumi-port

    This resource allows you to manage aggregation properties of a blueprint.

    See the Port documentation for more information about aggregation properties.

    Supported Methods:

    • count_entities - Count the entities of the target blueprint
    • average_entities - Average the entities of the target blueprint by time periods
    • average_by_property - Calculate the average by property value of the target entities
    • aggregate_by_property - Calculate the aggregate by property value of the target entities, such as sum, min, max, median

    Example Usage

    Create a parent blueprint with a child blueprint and an aggregation property to count the parent kids:

    import * as pulumi from "@pulumi/pulumi";
import * as port from "@pulumi/port";

const parentBlueprint = new port.index.Port_blueprint("parentBlueprint", {
    title: "Parent Blueprint",
    icon: "Terraform",
    identifier: "parent",
    description: "",
    properties: {
        numberProps: {
            age: {
                title: "Age",
            },
        },
    },
});
const childBlueprint = new port.index.Port_blueprint("childBlueprint", {
    title: "Child Blueprint",
    icon: "Terraform",
    identifier: "child",
    description: "",
    properties: {
        numberProps: {
            age: {
                title: "Age",
            },
        },
    },
    relations: {
        parent: {
            title: "Parent",
            target: parentBlueprint.identifier,
        },
    },
});
const parentAggregationProperties = new port.index.Port_aggregation_properties("parentAggregationProperties", {
    blueprintIdentifier: parentBlueprint.identifier,
    properties: {
        count_kids: {
            targetBlueprintIdentifier: childBlueprint.identifier,
            title: "Count Kids",
            icon: "Terraform",
            description: "Count Kids",
            method: {
                countEntities: true,
            },
        },
    },
});

    import pulumi
import pulumi_port as port

parent_blueprint = port.index.Port_blueprint("parentBlueprint",
    title=Parent Blueprint,
    icon=Terraform,
    identifier=parent,
    description=,
    properties={
        numberProps: {
            age: {
                title: Age,
            },
        },
    })
child_blueprint = port.index.Port_blueprint("childBlueprint",
    title=Child Blueprint,
    icon=Terraform,
    identifier=child,
    description=,
    properties={
        numberProps: {
            age: {
                title: Age,
            },
        },
    },
    relations={
        parent: {
            title: Parent,
            target: parent_blueprint.identifier,
        },
    })
parent_aggregation_properties = port.index.Port_aggregation_properties("parentAggregationProperties",
    blueprint_identifier=parent_blueprint.identifier,
    properties={
        count_kids: {
            targetBlueprintIdentifier: child_blueprint.identifier,
            title: Count Kids,
            icon: Terraform,
            description: Count Kids,
            method: {
                countEntities: True,
            },
        },
    })

    package main

import (
	"github.com/port-labs/pulumi-port/sdk/v2/go/port"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		parentBlueprint, err := port.NewPort_blueprint(ctx, "parentBlueprint", &port.Port_blueprintArgs{
			Title:       "Parent Blueprint",
			Icon:        "Terraform",
			Identifier:  "parent",
			Description: "",
			Properties: map[string]interface{}{
				"numberProps": map[string]interface{}{
					"age": map[string]interface{}{
						"title": "Age",
					},
				},
			},
		})
		if err != nil {
			return err
		}
		childBlueprint, err := port.NewPort_blueprint(ctx, "childBlueprint", &port.Port_blueprintArgs{
			Title:       "Child Blueprint",
			Icon:        "Terraform",
			Identifier:  "child",
			Description: "",
			Properties: map[string]interface{}{
				"numberProps": map[string]interface{}{
					"age": map[string]interface{}{
						"title": "Age",
					},
				},
			},
			Relations: map[string]interface{}{
				"parent": map[string]interface{}{
					"title":  "Parent",
					"target": parentBlueprint.Identifier,
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = port.NewPort_aggregation_properties(ctx, "parentAggregationProperties", &port.Port_aggregation_propertiesArgs{
			BlueprintIdentifier: parentBlueprint.Identifier,
			Properties: map[string]interface{}{
				"count_kids": map[string]interface{}{
					"targetBlueprintIdentifier": childBlueprint.Identifier,
					"title":                     "Count Kids",
					"icon":                      "Terraform",
					"description":               "Count Kids",
					"method": map[string]interface{}{
						"countEntities": true,
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Port = Pulumi.Port;

return await Deployment.RunAsync(() => 
{
    var parentBlueprint = new Port.Index.Port_blueprint("parentBlueprint", new()
    {
        Title = "Parent Blueprint",
        Icon = "Terraform",
        Identifier = "parent",
        Description = "",
        Properties = 
        {
            { "numberProps", 
            {
                { "age", 
                {
                    { "title", "Age" },
                } },
            } },
        },
    });

    var childBlueprint = new Port.Index.Port_blueprint("childBlueprint", new()
    {
        Title = "Child Blueprint",
        Icon = "Terraform",
        Identifier = "child",
        Description = "",
        Properties = 
        {
            { "numberProps", 
            {
                { "age", 
                {
                    { "title", "Age" },
                } },
            } },
        },
        Relations = 
        {
            { "parent", 
            {
                { "title", "Parent" },
                { "target", parentBlueprint.Identifier },
            } },
        },
    });

    var parentAggregationProperties = new Port.Index.Port_aggregation_properties("parentAggregationProperties", new()
    {
        BlueprintIdentifier = parentBlueprint.Identifier,
        Properties = 
        {
            { "count_kids", 
            {
                { "targetBlueprintIdentifier", childBlueprint.Identifier },
                { "title", "Count Kids" },
                { "icon", "Terraform" },
                { "description", "Count Kids" },
                { "method", 
                {
                    { "countEntities", true },
                } },
            } },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.port.port_blueprint;
import com.pulumi.port.Port_blueprintArgs;
import com.pulumi.port.port_aggregation_properties;
import com.pulumi.port.Port_aggregation_propertiesArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var parentBlueprint = new Port_blueprint("parentBlueprint", Port_blueprintArgs.builder()        
            .title("Parent Blueprint")
            .icon("Terraform")
            .identifier("parent")
            .description("")
            .properties(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .build());

        var childBlueprint = new Port_blueprint("childBlueprint", Port_blueprintArgs.builder()        
            .title("Child Blueprint")
            .icon("Terraform")
            .identifier("child")
            .description("")
            .properties(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .relations(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .build());

        var parentAggregationProperties = new Port_aggregation_properties("parentAggregationProperties", Port_aggregation_propertiesArgs.builder()        
            .blueprintIdentifier(parentBlueprint.identifier())
            .properties(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .build());

    }
}

    resources:
  parentBlueprint:
    type: port:port_blueprint
    properties:
      title: Parent Blueprint
      icon: Terraform
      identifier: parent
      description:
      properties:
        numberProps:
          age:
            title: Age
  childBlueprint:
    type: port:port_blueprint
    properties:
      title: Child Blueprint
      icon: Terraform
      identifier: child
      description:
      properties:
        numberProps:
          age:
            title: Age
      relations:
        parent:
          title: Parent
          target: ${parentBlueprint.identifier}
  parentAggregationProperties:
    type: port:port_aggregation_properties
    properties:
      blueprintIdentifier: ${parentBlueprint.identifier}
      properties:
        count_kids:
          targetBlueprintIdentifier: ${childBlueprint.identifier}
          title: Count Kids
          icon: Terraform
          description: Count Kids
          method:
            countEntities: true

    Create a parent blueprint with a child blueprint and an aggregation property to calculate the average avg of the parent kids age:

    import * as pulumi from "@pulumi/pulumi";
import * as port from "@pulumi/port";

const parentBlueprint = new port.index.Port_blueprint("parentBlueprint", {
    title: "Parent Blueprint",
    icon: "Terraform",
    identifier: "parent",
    description: "",
    properties: {
        numberProps: {
            age: {
                title: "Age",
            },
        },
    },
});
const childBlueprint = new port.index.Port_blueprint("childBlueprint", {
    title: "Child Blueprint",
    icon: "Terraform",
    identifier: "child",
    description: "",
    properties: {
        numberProps: {
            age: {
                title: "Age",
            },
        },
    },
    relations: {
        parent: {
            title: "Parent",
            target: parentBlueprint.identifier,
        },
    },
});
const parentAggregationProperties = new port.index.Port_aggregation_properties("parentAggregationProperties", {
    blueprintIdentifier: parentBlueprint.identifier,
    properties: {
        averageKidsAge: {
            targetBlueprintIdentifier: childBlueprint.identifier,
            title: "Average Kids Age",
            icon: "Terraform",
            description: "Average Kids Age",
            method: {
                averageByProperty: {
                    averageOf: "total",
                    measureTimeBy: "$createdAt",
                    property: "age",
                },
            },
        },
    },
});

    import pulumi
import pulumi_port as port

parent_blueprint = port.index.Port_blueprint("parentBlueprint",
    title=Parent Blueprint,
    icon=Terraform,
    identifier=parent,
    description=,
    properties={
        numberProps: {
            age: {
                title: Age,
            },
        },
    })
child_blueprint = port.index.Port_blueprint("childBlueprint",
    title=Child Blueprint,
    icon=Terraform,
    identifier=child,
    description=,
    properties={
        numberProps: {
            age: {
                title: Age,
            },
        },
    },
    relations={
        parent: {
            title: Parent,
            target: parent_blueprint.identifier,
        },
    })
parent_aggregation_properties = port.index.Port_aggregation_properties("parentAggregationProperties",
    blueprint_identifier=parent_blueprint.identifier,
    properties={
        averageKidsAge: {
            targetBlueprintIdentifier: child_blueprint.identifier,
            title: Average Kids Age,
            icon: Terraform,
            description: Average Kids Age,
            method: {
                averageByProperty: {
                    averageOf: total,
                    measureTimeBy: $createdAt,
                    property: age,
                },
            },
        },
    })

    package main

import (
	"github.com/port-labs/pulumi-port/sdk/v2/go/port"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		parentBlueprint, err := port.NewPort_blueprint(ctx, "parentBlueprint", &port.Port_blueprintArgs{
			Title:       "Parent Blueprint",
			Icon:        "Terraform",
			Identifier:  "parent",
			Description: "",
			Properties: map[string]interface{}{
				"numberProps": map[string]interface{}{
					"age": map[string]interface{}{
						"title": "Age",
					},
				},
			},
		})
		if err != nil {
			return err
		}
		childBlueprint, err := port.NewPort_blueprint(ctx, "childBlueprint", &port.Port_blueprintArgs{
			Title:       "Child Blueprint",
			Icon:        "Terraform",
			Identifier:  "child",
			Description: "",
			Properties: map[string]interface{}{
				"numberProps": map[string]interface{}{
					"age": map[string]interface{}{
						"title": "Age",
					},
				},
			},
			Relations: map[string]interface{}{
				"parent": map[string]interface{}{
					"title":  "Parent",
					"target": parentBlueprint.Identifier,
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = port.NewPort_aggregation_properties(ctx, "parentAggregationProperties", &port.Port_aggregation_propertiesArgs{
			BlueprintIdentifier: parentBlueprint.Identifier,
			Properties: map[string]interface{}{
				"averageKidsAge": map[string]interface{}{
					"targetBlueprintIdentifier": childBlueprint.Identifier,
					"title":                     "Average Kids Age",
					"icon":                      "Terraform",
					"description":               "Average Kids Age",
					"method": map[string]interface{}{
						"averageByProperty": map[string]interface{}{
							"averageOf":     "total",
							"measureTimeBy": "$createdAt",
							"property":      "age",
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Port = Pulumi.Port;

return await Deployment.RunAsync(() => 
{
    var parentBlueprint = new Port.Index.Port_blueprint("parentBlueprint", new()
    {
        Title = "Parent Blueprint",
        Icon = "Terraform",
        Identifier = "parent",
        Description = "",
        Properties = 
        {
            { "numberProps", 
            {
                { "age", 
                {
                    { "title", "Age" },
                } },
            } },
        },
    });

    var childBlueprint = new Port.Index.Port_blueprint("childBlueprint", new()
    {
        Title = "Child Blueprint",
        Icon = "Terraform",
        Identifier = "child",
        Description = "",
        Properties = 
        {
            { "numberProps", 
            {
                { "age", 
                {
                    { "title", "Age" },
                } },
            } },
        },
        Relations = 
        {
            { "parent", 
            {
                { "title", "Parent" },
                { "target", parentBlueprint.Identifier },
            } },
        },
    });

    var parentAggregationProperties = new Port.Index.Port_aggregation_properties("parentAggregationProperties", new()
    {
        BlueprintIdentifier = parentBlueprint.Identifier,
        Properties = 
        {
            { "averageKidsAge", 
            {
                { "targetBlueprintIdentifier", childBlueprint.Identifier },
                { "title", "Average Kids Age" },
                { "icon", "Terraform" },
                { "description", "Average Kids Age" },
                { "method", 
                {
                    { "averageByProperty", 
                    {
                        { "averageOf", "total" },
                        { "measureTimeBy", "$createdAt" },
                        { "property", "age" },
                    } },
                } },
            } },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.port.port_blueprint;
import com.pulumi.port.Port_blueprintArgs;
import com.pulumi.port.port_aggregation_properties;
import com.pulumi.port.Port_aggregation_propertiesArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var parentBlueprint = new Port_blueprint("parentBlueprint", Port_blueprintArgs.builder()        
            .title("Parent Blueprint")
            .icon("Terraform")
            .identifier("parent")
            .description("")
            .properties(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .build());

        var childBlueprint = new Port_blueprint("childBlueprint", Port_blueprintArgs.builder()        
            .title("Child Blueprint")
            .icon("Terraform")
            .identifier("child")
            .description("")
            .properties(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .relations(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .build());

        var parentAggregationProperties = new Port_aggregation_properties("parentAggregationProperties", Port_aggregation_propertiesArgs.builder()        
            .blueprintIdentifier(parentBlueprint.identifier())
            .properties(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .build());

    }
}

    resources:
  parentBlueprint:
    type: port:port_blueprint
    properties:
      title: Parent Blueprint
      icon: Terraform
      identifier: parent
      description:
      properties:
        numberProps:
          age:
            title: Age
  childBlueprint:
    type: port:port_blueprint
    properties:
      title: Child Blueprint
      icon: Terraform
      identifier: child
      description:
      properties:
        numberProps:
          age:
            title: Age
      relations:
        parent:
          title: Parent
          target: ${parentBlueprint.identifier}
  parentAggregationProperties:
    type: port:port_aggregation_properties
    properties:
      blueprintIdentifier: ${parentBlueprint.identifier}
      properties:
        averageKidsAge:
          targetBlueprintIdentifier: ${childBlueprint.identifier}
          title: Average Kids Age
          icon: Terraform
          description: Average Kids Age
          method:
            averageByProperty:
              averageOf: total
              measureTimeBy: $createdAt
              property: age

    Create a repository blueprint and a pull request blueprint and an aggregation property to calculate the average of pull requests created per day:

    import * as pulumi from "@pulumi/pulumi";
import * as port from "@pulumi/port";

const repositoryBlueprint = new port.index.Port_blueprint("repositoryBlueprint", {
    title: "Repository Blueprint",
    icon: "Terraform",
    identifier: "repository",
    description: "",
});
const pullRequestBlueprint = new port.index.Port_blueprint("pullRequestBlueprint", {
    title: "Pull Request Blueprint",
    icon: "Terraform",
    identifier: "pull_request",
    description: "",
    properties: {
        stringProps: {
            status: {
                title: "Status",
            },
        },
    },
    relations: {
        repository: {
            title: "Repository",
            target: repositoryBlueprint.identifier,
        },
    },
});
const repositoryAggregationProperties = new port.index.Port_aggregation_properties("repositoryAggregationProperties", {
    blueprintIdentifier: repositoryBlueprint.identifier,
    properties: {
        pull_requests_per_day: {
            targetBlueprintIdentifier: pullRequestBlueprint.identifier,
            title: "Pull Requests Per Day",
            icon: "Terraform",
            description: "Pull Requests Per Day",
            method: {
                averageEntities: {
                    averageOf: "day",
                    measureTimeBy: "$createdAt",
                },
            },
        },
    },
});

    import pulumi
import pulumi_port as port

repository_blueprint = port.index.Port_blueprint("repositoryBlueprint",
    title=Repository Blueprint,
    icon=Terraform,
    identifier=repository,
    description=)
pull_request_blueprint = port.index.Port_blueprint("pullRequestBlueprint",
    title=Pull Request Blueprint,
    icon=Terraform,
    identifier=pull_request,
    description=,
    properties={
        stringProps: {
            status: {
                title: Status,
            },
        },
    },
    relations={
        repository: {
            title: Repository,
            target: repository_blueprint.identifier,
        },
    })
repository_aggregation_properties = port.index.Port_aggregation_properties("repositoryAggregationProperties",
    blueprint_identifier=repository_blueprint.identifier,
    properties={
        pull_requests_per_day: {
            targetBlueprintIdentifier: pull_request_blueprint.identifier,
            title: Pull Requests Per Day,
            icon: Terraform,
            description: Pull Requests Per Day,
            method: {
                averageEntities: {
                    averageOf: day,
                    measureTimeBy: $createdAt,
                },
            },
        },
    })

    package main

import (
	"github.com/port-labs/pulumi-port/sdk/v2/go/port"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		repositoryBlueprint, err := port.NewPort_blueprint(ctx, "repositoryBlueprint", &port.Port_blueprintArgs{
			Title:       "Repository Blueprint",
			Icon:        "Terraform",
			Identifier:  "repository",
			Description: "",
		})
		if err != nil {
			return err
		}
		pullRequestBlueprint, err := port.NewPort_blueprint(ctx, "pullRequestBlueprint", &port.Port_blueprintArgs{
			Title:       "Pull Request Blueprint",
			Icon:        "Terraform",
			Identifier:  "pull_request",
			Description: "",
			Properties: map[string]interface{}{
				"stringProps": map[string]interface{}{
					"status": map[string]interface{}{
						"title": "Status",
					},
				},
			},
			Relations: map[string]interface{}{
				"repository": map[string]interface{}{
					"title":  "Repository",
					"target": repositoryBlueprint.Identifier,
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = port.NewPort_aggregation_properties(ctx, "repositoryAggregationProperties", &port.Port_aggregation_propertiesArgs{
			BlueprintIdentifier: repositoryBlueprint.Identifier,
			Properties: map[string]interface{}{
				"pull_requests_per_day": map[string]interface{}{
					"targetBlueprintIdentifier": pullRequestBlueprint.Identifier,
					"title":                     "Pull Requests Per Day",
					"icon":                      "Terraform",
					"description":               "Pull Requests Per Day",
					"method": map[string]interface{}{
						"averageEntities": map[string]interface{}{
							"averageOf":     "day",
							"measureTimeBy": "$createdAt",
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Port = Pulumi.Port;

return await Deployment.RunAsync(() => 
{
    var repositoryBlueprint = new Port.Index.Port_blueprint("repositoryBlueprint", new()
    {
        Title = "Repository Blueprint",
        Icon = "Terraform",
        Identifier = "repository",
        Description = "",
    });

    var pullRequestBlueprint = new Port.Index.Port_blueprint("pullRequestBlueprint", new()
    {
        Title = "Pull Request Blueprint",
        Icon = "Terraform",
        Identifier = "pull_request",
        Description = "",
        Properties = 
        {
            { "stringProps", 
            {
                { "status", 
                {
                    { "title", "Status" },
                } },
            } },
        },
        Relations = 
        {
            { "repository", 
            {
                { "title", "Repository" },
                { "target", repositoryBlueprint.Identifier },
            } },
        },
    });

    var repositoryAggregationProperties = new Port.Index.Port_aggregation_properties("repositoryAggregationProperties", new()
    {
        BlueprintIdentifier = repositoryBlueprint.Identifier,
        Properties = 
        {
            { "pull_requests_per_day", 
            {
                { "targetBlueprintIdentifier", pullRequestBlueprint.Identifier },
                { "title", "Pull Requests Per Day" },
                { "icon", "Terraform" },
                { "description", "Pull Requests Per Day" },
                { "method", 
                {
                    { "averageEntities", 
                    {
                        { "averageOf", "day" },
                        { "measureTimeBy", "$createdAt" },
                    } },
                } },
            } },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.port.port_blueprint;
import com.pulumi.port.Port_blueprintArgs;
import com.pulumi.port.port_aggregation_properties;
import com.pulumi.port.Port_aggregation_propertiesArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var repositoryBlueprint = new Port_blueprint("repositoryBlueprint", Port_blueprintArgs.builder()        
            .title("Repository Blueprint")
            .icon("Terraform")
            .identifier("repository")
            .description("")
            .build());

        var pullRequestBlueprint = new Port_blueprint("pullRequestBlueprint", Port_blueprintArgs.builder()        
            .title("Pull Request Blueprint")
            .icon("Terraform")
            .identifier("pull_request")
            .description("")
            .properties(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .relations(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .build());

        var repositoryAggregationProperties = new Port_aggregation_properties("repositoryAggregationProperties", Port_aggregation_propertiesArgs.builder()        
            .blueprintIdentifier(repositoryBlueprint.identifier())
            .properties(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .build());

    }
}

    resources:
  repositoryBlueprint:
    type: port:port_blueprint
    properties:
      title: Repository Blueprint
      icon: Terraform
      identifier: repository
      description:
  pullRequestBlueprint:
    type: port:port_blueprint
    properties:
      title: Pull Request Blueprint
      icon: Terraform
      identifier: pull_request
      description:
      properties:
        stringProps:
          status:
            title: Status
      relations:
        repository:
          title: Repository
          target: ${repositoryBlueprint.identifier}
  repositoryAggregationProperties:
    type: port:port_aggregation_properties
    properties:
      blueprintIdentifier: ${repositoryBlueprint.identifier}
      properties:
        pull_requests_per_day:
          targetBlueprintIdentifier: ${pullRequestBlueprint.identifier}
          title: Pull Requests Per Day
          icon: Terraform
          description: Pull Requests Per Day
          method:
            averageEntities:
              averageOf: day
              measureTimeBy: $createdAt

    Create a repository blueprint and a pull request blueprint and an aggregation property to calculate the average of fix pull request per month:

    To do that we will add a query to the aggregation property to filter only pull requests with fixed title:

    import * as pulumi from "@pulumi/pulumi";
import * as port from "@pulumi/port";

const repositoryBlueprint = new port.index.Port_blueprint("repositoryBlueprint", {
    title: "Repository Blueprint",
    icon: "Terraform",
    identifier: "repository",
    description: "",
});
const pullRequestBlueprint = new port.index.Port_blueprint("pullRequestBlueprint", {
    title: "Pull Request Blueprint",
    icon: "Terraform",
    identifier: "pull_request",
    description: "",
    properties: {
        stringProps: {
            status: {
                title: "Status",
            },
        },
    },
    relations: {
        repository: {
            title: "Repository",
            target: repositoryBlueprint.identifier,
        },
    },
});
const repositoryAggregationProperties = new port.index.Port_aggregation_properties("repositoryAggregationProperties", {
    blueprintIdentifier: repositoryBlueprint.identifier,
    properties: {
        fix_pull_requests_count: {
            targetBlueprintIdentifier: pullRequestBlueprint.identifier,
            title: "Pull Requests Per Day",
            icon: "Terraform",
            description: "Pull Requests Per Day",
            method: {
                averageEntities: {
                    averageOf: "month",
                    measureTimeBy: "$createdAt",
                },
            },
            query: JSON.stringify({
                combinator: "and",
                rules: [{
                    property: "$title",
                    operator: "ContainsAny",
                    value: [
                        "fix",
                        "fixed",
                        "fixing",
                        "Fix",
                    ],
                }],
            }),
        },
    },
});

    import pulumi
import json
import pulumi_port as port

repository_blueprint = port.index.Port_blueprint("repositoryBlueprint",
    title=Repository Blueprint,
    icon=Terraform,
    identifier=repository,
    description=)
pull_request_blueprint = port.index.Port_blueprint("pullRequestBlueprint",
    title=Pull Request Blueprint,
    icon=Terraform,
    identifier=pull_request,
    description=,
    properties={
        stringProps: {
            status: {
                title: Status,
            },
        },
    },
    relations={
        repository: {
            title: Repository,
            target: repository_blueprint.identifier,
        },
    })
repository_aggregation_properties = port.index.Port_aggregation_properties("repositoryAggregationProperties",
    blueprint_identifier=repository_blueprint.identifier,
    properties={
        fix_pull_requests_count: {
            targetBlueprintIdentifier: pull_request_blueprint.identifier,
            title: Pull Requests Per Day,
            icon: Terraform,
            description: Pull Requests Per Day,
            method: {
                averageEntities: {
                    averageOf: month,
                    measureTimeBy: $createdAt,
                },
            },
            query: json.dumps({
                combinator: and,
                rules: [{
                    property: $title,
                    operator: ContainsAny,
                    value: [
                        fix,
                        fixed,
                        fixing,
                        Fix,
                    ],
                }],
            }),
        },
    })

    package main

import (
	"encoding/json"

	"github.com/port-labs/pulumi-port/sdk/v2/go/port"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
repositoryBlueprint, err := port.NewPort_blueprint(ctx, "repositoryBlueprint", &port.Port_blueprintArgs{
Title: "Repository Blueprint",
Icon: "Terraform",
Identifier: "repository",
Description: "",
})
if err != nil {
return err
}
pullRequestBlueprint, err := port.NewPort_blueprint(ctx, "pullRequestBlueprint", &port.Port_blueprintArgs{
Title: "Pull Request Blueprint",
Icon: "Terraform",
Identifier: "pull_request",
Description: "",
Properties: map[string]interface{}{
"stringProps": map[string]interface{}{
"status": map[string]interface{}{
"title": "Status",
},
},
},
Relations: map[string]interface{}{
"repository": map[string]interface{}{
"title": "Repository",
"target": repositoryBlueprint.Identifier,
},
},
})
if err != nil {
return err
}
_, err = port.NewPort_aggregation_properties(ctx, "repositoryAggregationProperties", &port.Port_aggregation_propertiesArgs{
BlueprintIdentifier: repositoryBlueprint.Identifier,
Properties: tmpJSON0, err := json.Marshal(map[string]interface{}{
"combinator": "and",
"rules": []map[string]interface{}{
map[string]interface{}{
"property": "$title",
"operator": "ContainsAny",
"value": []string{
"fix",
"fixed",
"fixing",
"Fix",
},
},
},
})
if err != nil {
return err
}
json0 := string(tmpJSON0)
map[string]interface{}{
"fix_pull_requests_count": map[string]interface{}{
"targetBlueprintIdentifier": pullRequestBlueprint.Identifier,
"title": "Pull Requests Per Day",
"icon": "Terraform",
"description": "Pull Requests Per Day",
"method": map[string]interface{}{
"averageEntities": map[string]interface{}{
"averageOf": "month",
"measureTimeBy": "$createdAt",
},
},
"query": json0,
},
},
})
if err != nil {
return err
}
return nil
})
}

    using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Port = Pulumi.Port;

return await Deployment.RunAsync(() => 
{
    var repositoryBlueprint = new Port.Index.Port_blueprint("repositoryBlueprint", new()
    {
        Title = "Repository Blueprint",
        Icon = "Terraform",
        Identifier = "repository",
        Description = "",
    });

    var pullRequestBlueprint = new Port.Index.Port_blueprint("pullRequestBlueprint", new()
    {
        Title = "Pull Request Blueprint",
        Icon = "Terraform",
        Identifier = "pull_request",
        Description = "",
        Properties = 
        {
            { "stringProps", 
            {
                { "status", 
                {
                    { "title", "Status" },
                } },
            } },
        },
        Relations = 
        {
            { "repository", 
            {
                { "title", "Repository" },
                { "target", repositoryBlueprint.Identifier },
            } },
        },
    });

    var repositoryAggregationProperties = new Port.Index.Port_aggregation_properties("repositoryAggregationProperties", new()
    {
        BlueprintIdentifier = repositoryBlueprint.Identifier,
        Properties = 
        {
            { "fix_pull_requests_count", 
            {
                { "targetBlueprintIdentifier", pullRequestBlueprint.Identifier },
                { "title", "Pull Requests Per Day" },
                { "icon", "Terraform" },
                { "description", "Pull Requests Per Day" },
                { "method", 
                {
                    { "averageEntities", 
                    {
                        { "averageOf", "month" },
                        { "measureTimeBy", "$createdAt" },
                    } },
                } },
                { "query", JsonSerializer.Serialize(new Dictionary<string, object?>
                {
                    ["combinator"] = "and",
                    ["rules"] = new[]
                    {
                        new Dictionary<string, object?>
                        {
                            ["property"] = "$title",
                            ["operator"] = "ContainsAny",
                            ["value"] = new[]
                            {
                                "fix",
                                "fixed",
                                "fixing",
                                "Fix",
                            },
                        },
                    },
                }) },
            } },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.port.port_blueprint;
import com.pulumi.port.Port_blueprintArgs;
import com.pulumi.port.port_aggregation_properties;
import com.pulumi.port.Port_aggregation_propertiesArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var repositoryBlueprint = new Port_blueprint("repositoryBlueprint", Port_blueprintArgs.builder()        
            .title("Repository Blueprint")
            .icon("Terraform")
            .identifier("repository")
            .description("")
            .build());

        var pullRequestBlueprint = new Port_blueprint("pullRequestBlueprint", Port_blueprintArgs.builder()        
            .title("Pull Request Blueprint")
            .icon("Terraform")
            .identifier("pull_request")
            .description("")
            .properties(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .relations(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .build());

        var repositoryAggregationProperties = new Port_aggregation_properties("repositoryAggregationProperties", Port_aggregation_propertiesArgs.builder()        
            .blueprintIdentifier(repositoryBlueprint.identifier())
            .properties(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .build());

    }
}

    resources:
  repositoryBlueprint:
    type: port:port_blueprint
    properties:
      title: Repository Blueprint
      icon: Terraform
      identifier: repository
      description:
  pullRequestBlueprint:
    type: port:port_blueprint
    properties:
      title: Pull Request Blueprint
      icon: Terraform
      identifier: pull_request
      description:
      properties:
        stringProps:
          status:
            title: Status
      relations:
        repository:
          title: Repository
          target: ${repositoryBlueprint.identifier}
  repositoryAggregationProperties:
    type: port:port_aggregation_properties
    properties:
      blueprintIdentifier: ${repositoryBlueprint.identifier}
      properties:
        fix_pull_requests_count:
          targetBlueprintIdentifier: ${pullRequestBlueprint.identifier}
          title: Pull Requests Per Day
          icon: Terraform
          description: Pull Requests Per Day
          method:
            averageEntities:
              averageOf: month
              measureTimeBy: $createdAt
          query:
            fn::toJSON:
              combinator: and
              rules:
                - property: $title
                  operator: ContainsAny
                  value:
                    - fix
                    - fixed
                    - fixing
                    - Fix

    Create multiple aggregation properties in one resource:

    import * as pulumi from "@pulumi/pulumi";
import * as port from "@pulumi/port";

const repositoryBlueprint = new port.index.Port_blueprint("repositoryBlueprint", {
    title: "Repository Blueprint",
    icon: "Terraform",
    identifier: "repository",
    description: "",
});
const pullRequestBlueprint = new port.index.Port_blueprint("pullRequestBlueprint", {
    title: "Pull Request Blueprint",
    icon: "Terraform",
    identifier: "pull_request",
    description: "",
    properties: {
        stringProps: {
            status: {
                title: "Status",
            },
        },
    },
    relations: {
        repository: {
            title: "Repository",
            target: repositoryBlueprint.identifier,
        },
    },
});
const repositoryAggregationProperties = new port.index.Port_aggregation_properties("repositoryAggregationProperties", {
    blueprintIdentifier: repositoryBlueprint.identifier,
    properties: {
        pull_requests_per_day: {
            targetBlueprintIdentifier: pullRequestBlueprint.identifier,
            title: "Pull Requests Per Day",
            icon: "Terraform",
            description: "Pull Requests Per Day",
            method: {
                averageEntities: {
                    averageOf: "day",
                    measureTimeBy: "$createdAt",
                },
            },
        },
        overall_pull_requests_count: {
            targetBlueprintIdentifier: pullRequestBlueprint.identifier,
            title: "Overall Pull Requests Count",
            icon: "Terraform",
            description: "Overall Pull Requests Count",
            method: {
                countEntities: true,
            },
        },
    },
});

    import pulumi
import pulumi_port as port

repository_blueprint = port.index.Port_blueprint("repositoryBlueprint",
    title=Repository Blueprint,
    icon=Terraform,
    identifier=repository,
    description=)
pull_request_blueprint = port.index.Port_blueprint("pullRequestBlueprint",
    title=Pull Request Blueprint,
    icon=Terraform,
    identifier=pull_request,
    description=,
    properties={
        stringProps: {
            status: {
                title: Status,
            },
        },
    },
    relations={
        repository: {
            title: Repository,
            target: repository_blueprint.identifier,
        },
    })
repository_aggregation_properties = port.index.Port_aggregation_properties("repositoryAggregationProperties",
    blueprint_identifier=repository_blueprint.identifier,
    properties={
        pull_requests_per_day: {
            targetBlueprintIdentifier: pull_request_blueprint.identifier,
            title: Pull Requests Per Day,
            icon: Terraform,
            description: Pull Requests Per Day,
            method: {
                averageEntities: {
                    averageOf: day,
                    measureTimeBy: $createdAt,
                },
            },
        },
        overall_pull_requests_count: {
            targetBlueprintIdentifier: pull_request_blueprint.identifier,
            title: Overall Pull Requests Count,
            icon: Terraform,
            description: Overall Pull Requests Count,
            method: {
                countEntities: True,
            },
        },
    })

    package main

import (
	"github.com/port-labs/pulumi-port/sdk/v2/go/port"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		repositoryBlueprint, err := port.NewPort_blueprint(ctx, "repositoryBlueprint", &port.Port_blueprintArgs{
			Title:       "Repository Blueprint",
			Icon:        "Terraform",
			Identifier:  "repository",
			Description: "",
		})
		if err != nil {
			return err
		}
		pullRequestBlueprint, err := port.NewPort_blueprint(ctx, "pullRequestBlueprint", &port.Port_blueprintArgs{
			Title:       "Pull Request Blueprint",
			Icon:        "Terraform",
			Identifier:  "pull_request",
			Description: "",
			Properties: map[string]interface{}{
				"stringProps": map[string]interface{}{
					"status": map[string]interface{}{
						"title": "Status",
					},
				},
			},
			Relations: map[string]interface{}{
				"repository": map[string]interface{}{
					"title":  "Repository",
					"target": repositoryBlueprint.Identifier,
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = port.NewPort_aggregation_properties(ctx, "repositoryAggregationProperties", &port.Port_aggregation_propertiesArgs{
			BlueprintIdentifier: repositoryBlueprint.Identifier,
			Properties: map[string]interface{}{
				"pull_requests_per_day": map[string]interface{}{
					"targetBlueprintIdentifier": pullRequestBlueprint.Identifier,
					"title":                     "Pull Requests Per Day",
					"icon":                      "Terraform",
					"description":               "Pull Requests Per Day",
					"method": map[string]interface{}{
						"averageEntities": map[string]interface{}{
							"averageOf":     "day",
							"measureTimeBy": "$createdAt",
						},
					},
				},
				"overall_pull_requests_count": map[string]interface{}{
					"targetBlueprintIdentifier": pullRequestBlueprint.Identifier,
					"title":                     "Overall Pull Requests Count",
					"icon":                      "Terraform",
					"description":               "Overall Pull Requests Count",
					"method": map[string]interface{}{
						"countEntities": true,
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Port = Pulumi.Port;

return await Deployment.RunAsync(() => 
{
    var repositoryBlueprint = new Port.Index.Port_blueprint("repositoryBlueprint", new()
    {
        Title = "Repository Blueprint",
        Icon = "Terraform",
        Identifier = "repository",
        Description = "",
    });

    var pullRequestBlueprint = new Port.Index.Port_blueprint("pullRequestBlueprint", new()
    {
        Title = "Pull Request Blueprint",
        Icon = "Terraform",
        Identifier = "pull_request",
        Description = "",
        Properties = 
        {
            { "stringProps", 
            {
                { "status", 
                {
                    { "title", "Status" },
                } },
            } },
        },
        Relations = 
        {
            { "repository", 
            {
                { "title", "Repository" },
                { "target", repositoryBlueprint.Identifier },
            } },
        },
    });

    var repositoryAggregationProperties = new Port.Index.Port_aggregation_properties("repositoryAggregationProperties", new()
    {
        BlueprintIdentifier = repositoryBlueprint.Identifier,
        Properties = 
        {
            { "pull_requests_per_day", 
            {
                { "targetBlueprintIdentifier", pullRequestBlueprint.Identifier },
                { "title", "Pull Requests Per Day" },
                { "icon", "Terraform" },
                { "description", "Pull Requests Per Day" },
                { "method", 
                {
                    { "averageEntities", 
                    {
                        { "averageOf", "day" },
                        { "measureTimeBy", "$createdAt" },
                    } },
                } },
            } },
            { "overall_pull_requests_count", 
            {
                { "targetBlueprintIdentifier", pullRequestBlueprint.Identifier },
                { "title", "Overall Pull Requests Count" },
                { "icon", "Terraform" },
                { "description", "Overall Pull Requests Count" },
                { "method", 
                {
                    { "countEntities", true },
                } },
            } },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.port.port_blueprint;
import com.pulumi.port.Port_blueprintArgs;
import com.pulumi.port.port_aggregation_properties;
import com.pulumi.port.Port_aggregation_propertiesArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var repositoryBlueprint = new Port_blueprint("repositoryBlueprint", Port_blueprintArgs.builder()        
            .title("Repository Blueprint")
            .icon("Terraform")
            .identifier("repository")
            .description("")
            .build());

        var pullRequestBlueprint = new Port_blueprint("pullRequestBlueprint", Port_blueprintArgs.builder()        
            .title("Pull Request Blueprint")
            .icon("Terraform")
            .identifier("pull_request")
            .description("")
            .properties(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .relations(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .build());

        var repositoryAggregationProperties = new Port_aggregation_properties("repositoryAggregationProperties", Port_aggregation_propertiesArgs.builder()        
            .blueprintIdentifier(repositoryBlueprint.identifier())
            .properties(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .build());

    }
}

    resources:
  repositoryBlueprint:
    type: port:port_blueprint
    properties:
      title: Repository Blueprint
      icon: Terraform
      identifier: repository
      description:
  pullRequestBlueprint:
    type: port:port_blueprint
    properties:
      title: Pull Request Blueprint
      icon: Terraform
      identifier: pull_request
      description:
      properties:
        stringProps:
          status:
            title: Status
      relations:
        repository:
          title: Repository
          target: ${repositoryBlueprint.identifier}
  repositoryAggregationProperties:
    type: port:port_aggregation_properties
    properties:
      blueprintIdentifier: ${repositoryBlueprint.identifier}
      properties:
        pull_requests_per_day:
          targetBlueprintIdentifier: ${pullRequestBlueprint.identifier}
          title: Pull Requests Per Day
          icon: Terraform
          description: Pull Requests Per Day
          method:
            averageEntities:
              averageOf: day
              measureTimeBy: $createdAt
        overall_pull_requests_count:
          targetBlueprintIdentifier: ${pullRequestBlueprint.identifier}
          title: Overall Pull Requests Count
          icon: Terraform
          description: Overall Pull Requests Count
          method:
            countEntities: true

    Create AggregationProperties Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new AggregationProperties(name: string, args: AggregationPropertiesArgs, opts?: CustomResourceOptions);
    @overload
def AggregationProperties(resource_name: str,
                          args: AggregationPropertiesArgs,
                          opts: Optional[ResourceOptions] = None)

@overload
def AggregationProperties(resource_name: str,
                          opts: Optional[ResourceOptions] = None,
                          blueprint_identifier: Optional[str] = None,
                          properties: Optional[Mapping[str, AggregationPropertiesPropertiesArgs]] = None)
    func NewAggregationProperties(ctx *Context, name string, args AggregationPropertiesArgs, opts ...ResourceOption) (*AggregationProperties, error)
    public AggregationProperties(string name, AggregationPropertiesArgs args, CustomResourceOptions? opts = null)
    public AggregationProperties(String name, AggregationPropertiesArgs args)
public AggregationProperties(String name, AggregationPropertiesArgs args, CustomResourceOptions options)

    type: port:AggregationProperties
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args AggregationPropertiesArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args AggregationPropertiesArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args AggregationPropertiesArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args AggregationPropertiesArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args AggregationPropertiesArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

    The following reference example uses placeholder values for all input properties.

    var aggregationPropertiesResource = new Port.AggregationProperties("aggregationPropertiesResource", new()
{
    BlueprintIdentifier = "string",
    Properties = 
    {
        { "string", new Port.Inputs.AggregationPropertiesPropertiesArgs
        {
            Method = new Port.Inputs.AggregationPropertiesPropertiesMethodArgs
            {
                AggregateByProperty = new Port.Inputs.AggregationPropertiesPropertiesMethodAggregateByPropertyArgs
                {
                    Func = "string",
                    Property = "string",
                },
                AverageByProperty = new Port.Inputs.AggregationPropertiesPropertiesMethodAverageByPropertyArgs
                {
                    AverageOf = "string",
                    MeasureTimeBy = "string",
                    Property = "string",
                },
                AverageEntities = new Port.Inputs.AggregationPropertiesPropertiesMethodAverageEntitiesArgs
                {
                    AverageOf = "string",
                    MeasureTimeBy = "string",
                },
                CountEntities = false,
            },
            TargetBlueprintIdentifier = "string",
            Description = "string",
            Icon = "string",
            Query = "string",
            Title = "string",
        } },
    },
});

    example, err := port.NewAggregationProperties(ctx, "aggregationPropertiesResource", &port.AggregationPropertiesArgs{
	BlueprintIdentifier: pulumi.String("string"),
	Properties: port.AggregationPropertiesPropertiesMap{
		"string": &port.AggregationPropertiesPropertiesArgs{
			Method: &port.AggregationPropertiesPropertiesMethodArgs{
				AggregateByProperty: &port.AggregationPropertiesPropertiesMethodAggregateByPropertyArgs{
					Func:     pulumi.String("string"),
					Property: pulumi.String("string"),
				},
				AverageByProperty: &port.AggregationPropertiesPropertiesMethodAverageByPropertyArgs{
					AverageOf:     pulumi.String("string"),
					MeasureTimeBy: pulumi.String("string"),
					Property:      pulumi.String("string"),
				},
				AverageEntities: &port.AggregationPropertiesPropertiesMethodAverageEntitiesArgs{
					AverageOf:     pulumi.String("string"),
					MeasureTimeBy: pulumi.String("string"),
				},
				CountEntities: pulumi.Bool(false),
			},
			TargetBlueprintIdentifier: pulumi.String("string"),
			Description:               pulumi.String("string"),
			Icon:                      pulumi.String("string"),
			Query:                     pulumi.String("string"),
			Title:                     pulumi.String("string"),
		},
	},
})

    var aggregationPropertiesResource = new AggregationProperties("aggregationPropertiesResource", AggregationPropertiesArgs.builder()        
    .blueprintIdentifier("string")
    .properties(Map.of("string", Map.ofEntries(
        Map.entry("method", Map.ofEntries(
            Map.entry("aggregateByProperty", Map.ofEntries(
                Map.entry("func", "string"),
                Map.entry("property", "string")
            )),
            Map.entry("averageByProperty", Map.ofEntries(
                Map.entry("averageOf", "string"),
                Map.entry("measureTimeBy", "string"),
                Map.entry("property", "string")
            )),
            Map.entry("averageEntities", Map.ofEntries(
                Map.entry("averageOf", "string"),
                Map.entry("measureTimeBy", "string")
            )),
            Map.entry("countEntities", false)
        )),
        Map.entry("targetBlueprintIdentifier", "string"),
        Map.entry("description", "string"),
        Map.entry("icon", "string"),
        Map.entry("query", "string"),
        Map.entry("title", "string")
    )))
    .build());

    aggregation_properties_resource = port.AggregationProperties("aggregationPropertiesResource",
    blueprint_identifier="string",
    properties={
        "string": port.AggregationPropertiesPropertiesArgs(
            method=port.AggregationPropertiesPropertiesMethodArgs(
                aggregate_by_property=port.AggregationPropertiesPropertiesMethodAggregateByPropertyArgs(
                    func="string",
                    property="string",
                ),
                average_by_property=port.AggregationPropertiesPropertiesMethodAverageByPropertyArgs(
                    average_of="string",
                    measure_time_by="string",
                    property="string",
                ),
                average_entities=port.AggregationPropertiesPropertiesMethodAverageEntitiesArgs(
                    average_of="string",
                    measure_time_by="string",
                ),
                count_entities=False,
            ),
            target_blueprint_identifier="string",
            description="string",
            icon="string",
            query="string",
            title="string",
        ),
    })

    const aggregationPropertiesResource = new port.AggregationProperties("aggregationPropertiesResource", {
    blueprintIdentifier: "string",
    properties: {
        string: {
            method: {
                aggregateByProperty: {
                    func: "string",
                    property: "string",
                },
                averageByProperty: {
                    averageOf: "string",
                    measureTimeBy: "string",
                    property: "string",
                },
                averageEntities: {
                    averageOf: "string",
                    measureTimeBy: "string",
                },
                countEntities: false,
            },
            targetBlueprintIdentifier: "string",
            description: "string",
            icon: "string",
            query: "string",
            title: "string",
        },
    },
});

    type: port:AggregationProperties
properties:
    blueprintIdentifier: string
    properties:
        string:
            description: string
            icon: string
            method:
                aggregateByProperty:
                    func: string
                    property: string
                averageByProperty:
                    averageOf: string
                    measureTimeBy: string
                    property: string
                averageEntities:
                    averageOf: string
                    measureTimeBy: string
                countEntities: false
            query: string
            targetBlueprintIdentifier: string
            title: string

    AggregationProperties Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    The AggregationProperties resource accepts the following input properties:

    BlueprintIdentifier string
    The identifier of the blueprint the aggregation property will be added to
    Properties Dictionary<string, port_labs.Port.Inputs.AggregationPropertiesPropertiesArgs>
    The aggregation property of the blueprint
    BlueprintIdentifier string
    The identifier of the blueprint the aggregation property will be added to
    Properties map[string]AggregationPropertiesPropertiesArgs
    The aggregation property of the blueprint
    blueprintIdentifier String
    The identifier of the blueprint the aggregation property will be added to
    properties Map<String,AggregationPropertiesPropertiesArgs>
    The aggregation property of the blueprint
    blueprintIdentifier string
    The identifier of the blueprint the aggregation property will be added to
    properties {[key: string]: AggregationPropertiesPropertiesArgs}
    The aggregation property of the blueprint
    blueprint_identifier str
    The identifier of the blueprint the aggregation property will be added to
    properties Mapping[str, AggregationPropertiesPropertiesArgs]
    The aggregation property of the blueprint
    blueprintIdentifier String
    The identifier of the blueprint the aggregation property will be added to
    properties Map<Property Map>
    The aggregation property of the blueprint

    Outputs

    All input properties are implicitly available as output properties. Additionally, the AggregationProperties resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing AggregationProperties Resource

    Get an existing AggregationProperties resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: AggregationPropertiesState, opts?: CustomResourceOptions): AggregationProperties
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        blueprint_identifier: Optional[str] = None,
        properties: Optional[Mapping[str, AggregationPropertiesPropertiesArgs]] = None) -> AggregationProperties
    func GetAggregationProperties(ctx *Context, name string, id IDInput, state *AggregationPropertiesState, opts ...ResourceOption) (*AggregationProperties, error)
    public static AggregationProperties Get(string name, Input<string> id, AggregationPropertiesState? state, CustomResourceOptions? opts = null)
    public static AggregationProperties get(String name, Output<String> id, AggregationPropertiesState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    BlueprintIdentifier string
    The identifier of the blueprint the aggregation property will be added to
    Properties Dictionary<string, port_labs.Port.Inputs.AggregationPropertiesPropertiesArgs>
    The aggregation property of the blueprint
    BlueprintIdentifier string
    The identifier of the blueprint the aggregation property will be added to
    Properties map[string]AggregationPropertiesPropertiesArgs
    The aggregation property of the blueprint
    blueprintIdentifier String
    The identifier of the blueprint the aggregation property will be added to
    properties Map<String,AggregationPropertiesPropertiesArgs>
    The aggregation property of the blueprint
    blueprintIdentifier string
    The identifier of the blueprint the aggregation property will be added to
    properties {[key: string]: AggregationPropertiesPropertiesArgs}
    The aggregation property of the blueprint
    blueprint_identifier str
    The identifier of the blueprint the aggregation property will be added to
    properties Mapping[str, AggregationPropertiesPropertiesArgs]
    The aggregation property of the blueprint
    blueprintIdentifier String
    The identifier of the blueprint the aggregation property will be added to
    properties Map<Property Map>
    The aggregation property of the blueprint

    Supporting Types

    AggregationPropertiesProperties, AggregationPropertiesPropertiesArgs

    Method port_labs.Port.Inputs.AggregationPropertiesPropertiesMethod
    The aggregation method to perform on the target blueprint, one of countentities, averageentities, averagebyproperty, aggregatebyproperty
    TargetBlueprintIdentifier string
    The identifier of the blueprint to perform the aggregation on
    Description string
    The description of the aggregation property
    Icon string
    The icon of the aggregation property
    Query string
    Query to filter the target entities
    Title string
    The title of the aggregation property
    Method AggregationPropertiesPropertiesMethod
    The aggregation method to perform on the target blueprint, one of countentities, averageentities, averagebyproperty, aggregatebyproperty
    TargetBlueprintIdentifier string
    The identifier of the blueprint to perform the aggregation on
    Description string
    The description of the aggregation property
    Icon string
    The icon of the aggregation property
    Query string
    Query to filter the target entities
    Title string
    The title of the aggregation property
    method AggregationPropertiesPropertiesMethod
    The aggregation method to perform on the target blueprint, one of countentities, averageentities, averagebyproperty, aggregatebyproperty
    targetBlueprintIdentifier String
    The identifier of the blueprint to perform the aggregation on
    description String
    The description of the aggregation property
    icon String
    The icon of the aggregation property
    query String
    Query to filter the target entities
    title String
    The title of the aggregation property
    method AggregationPropertiesPropertiesMethod
    The aggregation method to perform on the target blueprint, one of countentities, averageentities, averagebyproperty, aggregatebyproperty
    targetBlueprintIdentifier string
    The identifier of the blueprint to perform the aggregation on
    description string
    The description of the aggregation property
    icon string
    The icon of the aggregation property
    query string
    Query to filter the target entities
    title string
    The title of the aggregation property
    method AggregationPropertiesPropertiesMethod
    The aggregation method to perform on the target blueprint, one of countentities, averageentities, averagebyproperty, aggregatebyproperty
    target_blueprint_identifier str
    The identifier of the blueprint to perform the aggregation on
    description str
    The description of the aggregation property
    icon str
    The icon of the aggregation property
    query str
    Query to filter the target entities
    title str
    The title of the aggregation property
    method Property Map
    The aggregation method to perform on the target blueprint, one of countentities, averageentities, averagebyproperty, aggregatebyproperty
    targetBlueprintIdentifier String
    The identifier of the blueprint to perform the aggregation on
    description String
    The description of the aggregation property
    icon String
    The icon of the aggregation property
    query String
    Query to filter the target entities
    title String
    The title of the aggregation property

    AggregationPropertiesPropertiesMethod, AggregationPropertiesPropertiesMethodArgs

    AggregateByProperty port_labs.Port.Inputs.AggregationPropertiesPropertiesMethodAggregateByProperty
    Function to calculate the aggregate by property value of the target entities, such as sum, min, max, median
    AverageByProperty port_labs.Port.Inputs.AggregationPropertiesPropertiesMethodAverageByProperty
    Function to calculate the average by property value of the target entities
    AverageEntities port_labs.Port.Inputs.AggregationPropertiesPropertiesMethodAverageEntities
    Function to average the entities of the target entities
    CountEntities bool
    Function to count the entities of the target entities
    AggregateByProperty AggregationPropertiesPropertiesMethodAggregateByProperty
    Function to calculate the aggregate by property value of the target entities, such as sum, min, max, median
    AverageByProperty AggregationPropertiesPropertiesMethodAverageByProperty
    Function to calculate the average by property value of the target entities
    AverageEntities AggregationPropertiesPropertiesMethodAverageEntities
    Function to average the entities of the target entities
    CountEntities bool
    Function to count the entities of the target entities
    aggregateByProperty AggregationPropertiesPropertiesMethodAggregateByProperty
    Function to calculate the aggregate by property value of the target entities, such as sum, min, max, median
    averageByProperty AggregationPropertiesPropertiesMethodAverageByProperty
    Function to calculate the average by property value of the target entities
    averageEntities AggregationPropertiesPropertiesMethodAverageEntities
    Function to average the entities of the target entities
    countEntities Boolean
    Function to count the entities of the target entities
    aggregateByProperty AggregationPropertiesPropertiesMethodAggregateByProperty
    Function to calculate the aggregate by property value of the target entities, such as sum, min, max, median
    averageByProperty AggregationPropertiesPropertiesMethodAverageByProperty
    Function to calculate the average by property value of the target entities
    averageEntities AggregationPropertiesPropertiesMethodAverageEntities
    Function to average the entities of the target entities
    countEntities boolean
    Function to count the entities of the target entities
    aggregate_by_property AggregationPropertiesPropertiesMethodAggregateByProperty
    Function to calculate the aggregate by property value of the target entities, such as sum, min, max, median
    average_by_property AggregationPropertiesPropertiesMethodAverageByProperty
    Function to calculate the average by property value of the target entities
    average_entities AggregationPropertiesPropertiesMethodAverageEntities
    Function to average the entities of the target entities
    count_entities bool
    Function to count the entities of the target entities
    aggregateByProperty Property Map
    Function to calculate the aggregate by property value of the target entities, such as sum, min, max, median
    averageByProperty Property Map
    Function to calculate the average by property value of the target entities
    averageEntities Property Map
    Function to average the entities of the target entities
    countEntities Boolean
    Function to count the entities of the target entities

    AggregationPropertiesPropertiesMethodAggregateByProperty, AggregationPropertiesPropertiesMethodAggregateByPropertyArgs

    Func string
    The func of the aggregate by property
    Property string
    The property of the aggregate by property
    Func string
    The func of the aggregate by property
    Property string
    The property of the aggregate by property
    func String
    The func of the aggregate by property
    property String
    The property of the aggregate by property
    func string
    The func of the aggregate by property
    property string
    The property of the aggregate by property
    func str
    The func of the aggregate by property
    property str
    The property of the aggregate by property
    func String
    The func of the aggregate by property
    property String
    The property of the aggregate by property

    AggregationPropertiesPropertiesMethodAverageByProperty, AggregationPropertiesPropertiesMethodAverageByPropertyArgs

    AverageOf string
    The time periods to calculate the average by, e.g. hour, day, week, month
    MeasureTimeBy string
    The property name on which to calculate the the time periods, e.g. $createdAt, $updated_at or any other date property
    Property string
    The property name on which to calculate the average by
    AverageOf string
    The time periods to calculate the average by, e.g. hour, day, week, month
    MeasureTimeBy string
    The property name on which to calculate the the time periods, e.g. $createdAt, $updated_at or any other date property
    Property string
    The property name on which to calculate the average by
    averageOf String
    The time periods to calculate the average by, e.g. hour, day, week, month
    measureTimeBy String
    The property name on which to calculate the the time periods, e.g. $createdAt, $updated_at or any other date property
    property String
    The property name on which to calculate the average by
    averageOf string
    The time periods to calculate the average by, e.g. hour, day, week, month
    measureTimeBy string
    The property name on which to calculate the the time periods, e.g. $createdAt, $updated_at or any other date property
    property string
    The property name on which to calculate the average by
    average_of str
    The time periods to calculate the average by, e.g. hour, day, week, month
    measure_time_by str
    The property name on which to calculate the the time periods, e.g. $createdAt, $updated_at or any other date property
    property str
    The property name on which to calculate the average by
    averageOf String
    The time periods to calculate the average by, e.g. hour, day, week, month
    measureTimeBy String
    The property name on which to calculate the the time periods, e.g. $createdAt, $updated_at or any other date property
    property String
    The property name on which to calculate the average by

    AggregationPropertiesPropertiesMethodAverageEntities, AggregationPropertiesPropertiesMethodAverageEntitiesArgs

    AverageOf string
    The time periods to calculate the average of, e.g. hour, day, week, month
    MeasureTimeBy string
    The property name on which to calculate the the time periods, e.g. $createdAt, $updated_at or any other date property
    AverageOf string
    The time periods to calculate the average of, e.g. hour, day, week, month
    MeasureTimeBy string
    The property name on which to calculate the the time periods, e.g. $createdAt, $updated_at or any other date property
    averageOf String
    The time periods to calculate the average of, e.g. hour, day, week, month
    measureTimeBy String
    The property name on which to calculate the the time periods, e.g. $createdAt, $updated_at or any other date property
    averageOf string
    The time periods to calculate the average of, e.g. hour, day, week, month
    measureTimeBy string
    The property name on which to calculate the the time periods, e.g. $createdAt, $updated_at or any other date property
    average_of str
    The time periods to calculate the average of, e.g. hour, day, week, month
    measure_time_by str
    The property name on which to calculate the the time periods, e.g. $createdAt, $updated_at or any other date property
    averageOf String
    The time periods to calculate the average of, e.g. hour, day, week, month
    measureTimeBy String
    The property name on which to calculate the the time periods, e.g. $createdAt, $updated_at or any other date property

    Package Details

    Repository
    port port-labs/pulumi-port
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the port-labs Terraform Provider.
    port logo
    Port v2.0.1 published on Monday, May 13, 2024 by port-labs
    port-labs/pulumi-port