resource_model

package
v1.4.17 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 14, 2024 License: MIT Imports: 8 Imported by: 3

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var AuditLogMapperInstance = NewAuditLogMapper()
View Source 
var AuditLogResource = &model.Resource{
	Name:      "AuditLog",
	Namespace: "system",
	Properties: []*model.ResourceProperty{
		{
			Name:         "id",
			Type:         model.ResourceProperty_UUID,
			Primary:      true,
			Required:     true,
			Immutable:    true,
			ExampleValue: structpb.NewStringValue("a39621a4-6d48-11ee-b962-0242ac120002"),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:         "version",
			Type:         model.ResourceProperty_INT32,
			Required:     true,
			DefaultValue: structpb.NewNumberValue(1),
			ExampleValue: structpb.NewNumberValue(1),

			Annotations: map[string]string{
				"SpecialProperty":     "true",
				"AllowEmptyPrimitive": "true",
			},
		},
		{
			Name:     "namespace",
			Type:     model.ResourceProperty_STRING,
			Length:   256,
			Required: true,
		},
		{
			Name:     "resource",
			Type:     model.ResourceProperty_STRING,
			Length:   256,
			Required: true,
		},
		{
			Name:     "recordId",
			Type:     model.ResourceProperty_STRING,
			Length:   256,
			Required: true,

			Annotations: map[string]string{
				"SourceDef": "record_id",
			},
		},
		{
			Name:     "time",
			Type:     model.ResourceProperty_TIMESTAMP,
			Required: true,
		},
		{
			Name:     "username",
			Type:     model.ResourceProperty_STRING,
			Required: true,
		},
		{
			Name:       "operation",
			Type:       model.ResourceProperty_ENUM,
			Required:   true,
			EnumValues: []string{"CREATE", "UPDATE", "DELETE"},
		},
		{
			Name: "properties",
			Type: model.ResourceProperty_OBJECT,
		},
		{
			Name: "annotations",
			Type: model.ResourceProperty_MAP,
			Item: &model.ResourceProperty{
				Name: "",
				Type: model.ResourceProperty_STRING,
			},
			ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"CheckVersion": structpb.NewStringValue("true"), "IgnoreIfExists": structpb.NewStringValue("true"), "CommonType": structpb.NewStringValue("testType")}}),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
	},
	Immutable: true,

	Annotations: map[string]string{
		"BypassExtensions": "true",
		"OpenApiGroup":     "internal",
	},
}
View Source 
var BooleanExpressionMapperInstance = NewBooleanExpressionMapper()
View Source 
var ChannelCallMapperInstance = NewChannelCallMapper()
View Source 
var DataSourceAuditDataMapperInstance = NewDataSourceAuditDataMapper()
View Source 
var DataSourceMapperInstance = NewDataSourceMapper()
View Source 
var DataSourceResource = &model.Resource{
	Name:      "DataSource",
	Namespace: "system",
	Types: []*model.ResourceSubType{
		{
			Name:        "AuditData",
			Title:       "Audit Data",
			Description: "Audit Data is a type that represents the audit data of a resource/record. ",
			Properties: []*model.ResourceProperty{
				{
					Name:         "createdBy",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					Immutable:    true,
					ExampleValue: structpb.NewStringValue("admin"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "updatedBy",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("admin"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "createdOn",
					Type:         model.ResourceProperty_TIMESTAMP,
					Immutable:    true,
					ExampleValue: structpb.NewStringValue("2024-05-03T21:31:07+04:00"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "updatedOn",
					Type:         model.ResourceProperty_TIMESTAMP,
					ExampleValue: structpb.NewStringValue("2024-05-03T21:31:07+04:00"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "internal",
			},
		},
	},
	Properties: []*model.ResourceProperty{
		{
			Name:         "id",
			Type:         model.ResourceProperty_UUID,
			Primary:      true,
			Required:     true,
			Immutable:    true,
			ExampleValue: structpb.NewStringValue("a39621a4-6d48-11ee-b962-0242ac120002"),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:         "version",
			Type:         model.ResourceProperty_INT32,
			Required:     true,
			DefaultValue: structpb.NewNumberValue(1),
			ExampleValue: structpb.NewNumberValue(1),

			Annotations: map[string]string{
				"SpecialProperty":     "true",
				"AllowEmptyPrimitive": "true",
			},
		},
		{
			Name:         "auditData",
			Type:         model.ResourceProperty_STRUCT,
			TypeRef:      util.Pointer("AuditData"),
			ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"createdBy": structpb.NewStringValue("admin"), "updatedBy": structpb.NewStringValue("admin"), "createdOn": structpb.NewStringValue("2024-05-03T21:31:07+04:00"), "updatedOn": structpb.NewStringValue("2024-05-03T21:31:07+04:00")}}),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:     "name",
			Type:     model.ResourceProperty_STRING,
			Length:   64,
			Required: true,
			Unique:   true,

			Annotations: map[string]string{
				"IsHclLabel": "true",
			},
		},
		{
			Name:   "description",
			Type:   model.ResourceProperty_STRING,
			Length: 64,

			Annotations: map[string]string{
				"AllowEmptyPrimitive": "true",
			},
		},
		{
			Name:     "backend",
			Type:     model.ResourceProperty_STRING,
			Required: true,
		},
		{
			Name:     "options",
			Type:     model.ResourceProperty_MAP,
			Required: true,
			Item: &model.ResourceProperty{
				Name: "",
				Type: model.ResourceProperty_STRING,
			},
		},
	},

	Annotations: map[string]string{
		"EnableAudit":  "true",
		"OpenApiGroup": "internal",
	},
}
View Source 
var ErrorFieldMapperInstance = NewErrorFieldMapper()
View Source 
var ErrorMapperInstance = NewErrorMapper()
View Source 
var EventMapperInstance = NewEventMapper()
View Source 
var EventSelectorMapperInstance = NewEventSelectorMapper()
View Source 
var ExpressionMapperInstance = NewExpressionMapper()
View Source 
var ExtensionAuditDataMapperInstance = NewExtensionAuditDataMapper()
View Source 
var ExtensionMapperInstance = NewExtensionMapper()
View Source 
var ExtensionResource = &model.Resource{
	Name:      "Extension",
	Namespace: "system",
	Types: []*model.ResourceSubType{
		{
			Name: "BooleanExpression",
			Properties: []*model.ResourceProperty{
				{
					Name: "and",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Name:    "",
						Type:    model.ResourceProperty_STRUCT,
						TypeRef: util.Pointer("BooleanExpression"),
					},
				},
				{
					Name: "or",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Name:    "",
						Type:    model.ResourceProperty_STRUCT,
						TypeRef: util.Pointer("BooleanExpression"),
					},
				},
				{
					Name:    "not",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("BooleanExpression"),
				},
				{
					Name:    "equal",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "lessThan",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "greaterThan",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "lessThanOrEqual",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "greaterThanOrEqual",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "in",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "like",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "ilike",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "regex",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "isNull",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("Expression"),
				},
				{
					Name: "filters",
					Type: model.ResourceProperty_MAP,
					Item: &model.ResourceProperty{
						Name: "",
						Type: model.ResourceProperty_OBJECT,
					},
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "internal",
			},
		},
		{
			Name: "PairExpression",
			Properties: []*model.ResourceProperty{
				{
					Name:    "left",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("Expression"),
				},
				{
					Name:    "right",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("Expression"),
				},
			},

			Annotations: map[string]string{
				"OpenApiGroup": "internal",
				"EnableAudit":  "true",
			},
		},
		{
			Name: "Expression",
			Properties: []*model.ResourceProperty{
				{
					Name: "property",
					Type: model.ResourceProperty_STRING,
				},
				{
					Name: "value",
					Type: model.ResourceProperty_OBJECT,
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "internal",
			},
		},
		{
			Name:        "AuditData",
			Title:       "Audit Data",
			Description: "Audit Data is a type that represents the audit data of a resource/record. ",
			Properties: []*model.ResourceProperty{
				{
					Name:         "createdBy",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					Immutable:    true,
					ExampleValue: structpb.NewStringValue("admin"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "updatedBy",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("admin"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "createdOn",
					Type:         model.ResourceProperty_TIMESTAMP,
					Immutable:    true,
					ExampleValue: structpb.NewStringValue("2024-05-03T21:31:07+04:00"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "updatedOn",
					Type:         model.ResourceProperty_TIMESTAMP,
					ExampleValue: structpb.NewStringValue("2024-05-03T21:31:07+04:00"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "internal",
			},
		},
		{
			Name: "FunctionCall",
			Properties: []*model.ResourceProperty{
				{
					Name:     "host",
					Type:     model.ResourceProperty_STRING,
					Required: true,
				},
				{
					Name:     "functionName",
					Type:     model.ResourceProperty_STRING,
					Required: true,
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "internal",
			},
		},
		{
			Name: "HttpCall",
			Properties: []*model.ResourceProperty{
				{
					Name:     "uri",
					Type:     model.ResourceProperty_STRING,
					Required: true,
				},
				{
					Name:     "method",
					Type:     model.ResourceProperty_STRING,
					Required: true,
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "internal",
			},
		},
		{
			Name: "ChannelCall",
			Properties: []*model.ResourceProperty{
				{
					Name:     "channelKey",
					Type:     model.ResourceProperty_STRING,
					Required: true,
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "internal",
			},
		},
		{
			Name: "ExternalCall",
			Properties: []*model.ResourceProperty{
				{
					Name:    "functionCall",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("FunctionCall"),
				},
				{
					Name:    "httpCall",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("HttpCall"),
				},
				{
					Name:    "channelCall",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("ChannelCall"),
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "internal",
			},
		},
		{
			Name: "EventSelector",
			Properties: []*model.ResourceProperty{
				{
					Name: "actions",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Name:       "action",
						Type:       model.ResourceProperty_ENUM,
						EnumValues: []string{"CREATE", "UPDATE", "DELETE", "GET", "LIST", "OPERATE"},

						Annotations: map[string]string{
							"TypeName": "EventAction",
						},
					},
				},
				{
					Name:    "recordSelector",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("BooleanExpression"),
				},
				{
					Name: "namespaces",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Name: "",
						Type: model.ResourceProperty_STRING,
					},
				},
				{
					Name: "resources",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Name: "",
						Type: model.ResourceProperty_STRING,
					},
				},
				{
					Name: "ids",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Name: "",
						Type: model.ResourceProperty_STRING,
					},
				},
				{
					Name: "annotations",
					Type: model.ResourceProperty_MAP,
					Item: &model.ResourceProperty{
						Name: "",
						Type: model.ResourceProperty_STRING,
					},
					ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"CommonType": structpb.NewStringValue("testType"), "CheckVersion": structpb.NewStringValue("true"), "IgnoreIfExists": structpb.NewStringValue("true")}}),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "internal",
			},
		},
		{
			Name: "RecordSearchParams",
			Properties: []*model.ResourceProperty{
				{
					Name:    "query",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("BooleanExpression"),
				},
				{
					Name: "limit",
					Type: model.ResourceProperty_INT32,
				},
				{
					Name: "offset",
					Type: model.ResourceProperty_INT32,
				},
				{
					Name: "resolveReferences",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Name: "",
						Type: model.ResourceProperty_STRING,
					},
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "internal",
			},
		},
		{
			Name: "Event",
			Properties: []*model.ResourceProperty{
				{
					Name:      "id",
					Type:      model.ResourceProperty_STRING,
					Required:  true,
					Immutable: true,
				},
				{
					Name:       "action",
					Type:       model.ResourceProperty_ENUM,
					Required:   true,
					EnumValues: []string{"CREATE", "UPDATE", "DELETE", "GET", "LIST", "OPERATE"},
				},
				{
					Name:    "recordSearchParams",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("RecordSearchParams"),
				},
				{
					Name:      "resource",
					Type:      model.ResourceProperty_REFERENCE,
					Reference: &model.Reference{Resource: "Resource", Namespace: ""},
				},
				{
					Name: "records",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Name:      "",
						Type:      model.ResourceProperty_REFERENCE,
						Reference: &model.Reference{Resource: "Record", Namespace: ""},
					},
				},
				{
					Name: "finalizes",
					Type: model.ResourceProperty_BOOL,
				},
				{
					Name: "sync",
					Type: model.ResourceProperty_BOOL,
				},
				{
					Name: "time",
					Type: model.ResourceProperty_TIMESTAMP,
				},
				{
					Name: "total",
					Type: model.ResourceProperty_INT64,
				},
				{
					Name: "annotations",
					Type: model.ResourceProperty_MAP,
					Item: &model.ResourceProperty{
						Name: "",
						Type: model.ResourceProperty_STRING,
					},
					ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"CheckVersion": structpb.NewStringValue("true"), "IgnoreIfExists": structpb.NewStringValue("true"), "CommonType": structpb.NewStringValue("testType")}}),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:    "error",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("Error"),
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "internal",
			},
		},
		{
			Name: "ErrorField",
			Properties: []*model.ResourceProperty{
				{
					Name: "recordId",
					Type: model.ResourceProperty_STRING,
				},
				{
					Name: "property",
					Type: model.ResourceProperty_STRING,
				},
				{
					Name: "message",
					Type: model.ResourceProperty_STRING,
				},
				{
					Name: "value",
					Type: model.ResourceProperty_OBJECT,
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "internal",
			},
		},
		{
			Name: "Error",
			Properties: []*model.ResourceProperty{
				{
					Name:       "code",
					Type:       model.ResourceProperty_ENUM,
					EnumValues: []string{"UNKNOWN_ERROR", "RECORD_NOT_FOUND", "UNABLE_TO_LOCATE_PRIMARY_KEY", "INTERNAL_ERROR", "PROPERTY_NOT_FOUND", "RECORD_VALIDATION_ERROR", "RESOURCE_VALIDATION_ERROR", "AUTHENTICATION_FAILED", "ALREADY_EXISTS", "ACCESS_DENIED", "BACKEND_ERROR", "UNIQUE_VIOLATION", "REFERENCE_VIOLATION", "RESOURCE_NOT_FOUND", "UNSUPPORTED_OPERATION", "EXTERNAL_BACKEND_COMMUNICATION_ERROR", "EXTERNAL_BACKEND_ERROR", "RATE_LIMIT_ERROR"},
				},
				{
					Name: "message",
					Type: model.ResourceProperty_STRING,
				},
				{
					Name: "fields",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Name:    "",
						Type:    model.ResourceProperty_STRUCT,
						TypeRef: util.Pointer("ErrorField"),
					},
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "internal",
			},
		},
	},
	Properties: []*model.ResourceProperty{
		{
			Name:         "id",
			Type:         model.ResourceProperty_UUID,
			Primary:      true,
			Required:     true,
			Immutable:    true,
			ExampleValue: structpb.NewStringValue("a39621a4-6d48-11ee-b962-0242ac120002"),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:         "version",
			Type:         model.ResourceProperty_INT32,
			Required:     true,
			DefaultValue: structpb.NewNumberValue(1),
			ExampleValue: structpb.NewNumberValue(1),

			Annotations: map[string]string{
				"SpecialProperty":     "true",
				"AllowEmptyPrimitive": "true",
			},
		},
		{
			Name:         "auditData",
			Type:         model.ResourceProperty_STRUCT,
			TypeRef:      util.Pointer("AuditData"),
			ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"createdBy": structpb.NewStringValue("admin"), "updatedBy": structpb.NewStringValue("admin"), "createdOn": structpb.NewStringValue("2024-05-03T21:31:07+04:00"), "updatedOn": structpb.NewStringValue("2024-05-03T21:31:07+04:00")}}),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:     "name",
			Type:     model.ResourceProperty_STRING,
			Length:   256,
			Required: true,
			Unique:   true,

			Annotations: map[string]string{
				"IsHclLabel": "true",
			},
		},
		{
			Name:   "description",
			Type:   model.ResourceProperty_STRING,
			Length: 1024,
		},
		{
			Name:    "selector",
			Type:    model.ResourceProperty_STRUCT,
			TypeRef: util.Pointer("EventSelector"),
		},
		{
			Name:     "order",
			Type:     model.ResourceProperty_INT32,
			Required: true,
		},
		{
			Name:     "finalizes",
			Type:     model.ResourceProperty_BOOL,
			Required: true,
		},
		{
			Name:     "sync",
			Type:     model.ResourceProperty_BOOL,
			Required: true,
		},
		{
			Name:     "responds",
			Type:     model.ResourceProperty_BOOL,
			Required: true,
		},
		{
			Name:     "call",
			Type:     model.ResourceProperty_STRUCT,
			Required: true,
			TypeRef:  util.Pointer("ExternalCall"),
		},
		{
			Name: "annotations",
			Type: model.ResourceProperty_MAP,
			Item: &model.ResourceProperty{
				Name: "",
				Type: model.ResourceProperty_STRING,
			},
			ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"IgnoreIfExists": structpb.NewStringValue("true"), "CommonType": structpb.NewStringValue("testType"), "CheckVersion": structpb.NewStringValue("true")}}),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
	},

	Annotations: map[string]string{
		"EnableAudit":  "true",
		"OpenApiGroup": "internal",
	},
}
View Source 
var ExternalCallMapperInstance = NewExternalCallMapper()
View Source 
var FunctionCallMapperInstance = NewFunctionCallMapper()
View Source 
var HttpCallMapperInstance = NewHttpCallMapper()
View Source 
var NamespaceAuditDataMapperInstance = NewNamespaceAuditDataMapper()
View Source 
var NamespaceMapperInstance = NewNamespaceMapper()
View Source 
var NamespaceResource = &model.Resource{
	Name:      "Namespace",
	Namespace: "system",
	Types: []*model.ResourceSubType{
		{
			Name:        "AuditData",
			Title:       "Audit Data",
			Description: "Audit Data is a type that represents the audit data of a resource/record. ",
			Properties: []*model.ResourceProperty{
				{
					Name:         "createdBy",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					Immutable:    true,
					ExampleValue: structpb.NewStringValue("admin"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "updatedBy",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("admin"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "createdOn",
					Type:         model.ResourceProperty_TIMESTAMP,
					Immutable:    true,
					ExampleValue: structpb.NewStringValue("2024-05-03T21:31:07+04:00"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "updatedOn",
					Type:         model.ResourceProperty_TIMESTAMP,
					ExampleValue: structpb.NewStringValue("2024-05-03T21:31:07+04:00"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "internal",
			},
		},
	},
	Properties: []*model.ResourceProperty{
		{
			Name:         "id",
			Type:         model.ResourceProperty_UUID,
			Primary:      true,
			Required:     true,
			Immutable:    true,
			ExampleValue: structpb.NewStringValue("a39621a4-6d48-11ee-b962-0242ac120002"),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:         "version",
			Type:         model.ResourceProperty_INT32,
			Required:     true,
			DefaultValue: structpb.NewNumberValue(1),
			ExampleValue: structpb.NewNumberValue(1),

			Annotations: map[string]string{
				"SpecialProperty":     "true",
				"AllowEmptyPrimitive": "true",
			},
		},
		{
			Name:         "auditData",
			Type:         model.ResourceProperty_STRUCT,
			TypeRef:      util.Pointer("AuditData"),
			ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"createdBy": structpb.NewStringValue("admin"), "updatedBy": structpb.NewStringValue("admin"), "createdOn": structpb.NewStringValue("2024-05-03T21:31:07+04:00"), "updatedOn": structpb.NewStringValue("2024-05-03T21:31:07+04:00")}}),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:      "name",
			Type:      model.ResourceProperty_STRING,
			Length:    256,
			Required:  true,
			Unique:    true,
			Immutable: true,

			Annotations: map[string]string{
				"IsHclLabel": "true",
			},
		},
		{
			Name:   "description",
			Type:   model.ResourceProperty_STRING,
			Length: 256,
		},
		{
			Name: "details",
			Type: model.ResourceProperty_OBJECT,
		},
	},

	Annotations: map[string]string{
		"EnableAudit":  "true",
		"OpenApiGroup": "internal",
	},
}
View Source 
var PairExpressionMapperInstance = NewPairExpressionMapper()
View Source 
var PermissionAuditDataMapperInstance = NewPermissionAuditDataMapper()
View Source 
var PermissionMapperInstance = NewPermissionMapper()
View Source 
var PermissionResource = &model.Resource{
	Name:        "Permission",
	Namespace:   "system",
	Title:       util.Pointer("Permission"),
	Description: util.Pointer("Permission is a resource that defines the access control rules for resources for users."),
	Types: []*model.ResourceSubType{
		{
			Name:        "AuditData",
			Title:       "Audit Data",
			Description: "Audit Data is a type that represents the audit data of a resource/record. ",
			Properties: []*model.ResourceProperty{
				{
					Name:         "createdBy",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					Immutable:    true,
					ExampleValue: structpb.NewStringValue("admin"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "updatedBy",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("admin"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "createdOn",
					Type:         model.ResourceProperty_TIMESTAMP,
					Immutable:    true,
					ExampleValue: structpb.NewStringValue("2024-05-03T21:31:07+04:00"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "updatedOn",
					Type:         model.ResourceProperty_TIMESTAMP,
					ExampleValue: structpb.NewStringValue("2024-05-03T21:31:07+04:00"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "meta",
			},
		},
		{
			Name: "BooleanExpression",
			Properties: []*model.ResourceProperty{
				{
					Name: "and",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Name:    "",
						Type:    model.ResourceProperty_STRUCT,
						TypeRef: util.Pointer("BooleanExpression"),
					},
				},
				{
					Name: "or",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Name:    "",
						Type:    model.ResourceProperty_STRUCT,
						TypeRef: util.Pointer("BooleanExpression"),
					},
				},
				{
					Name:    "not",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("BooleanExpression"),
				},
				{
					Name:    "equal",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "lessThan",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "greaterThan",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "lessThanOrEqual",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "greaterThanOrEqual",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "in",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "like",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "ilike",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "regex",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("PairExpression"),
				},
				{
					Name:    "isNull",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("Expression"),
				},
				{
					Name: "filters",
					Type: model.ResourceProperty_MAP,
					Item: &model.ResourceProperty{
						Name: "",
						Type: model.ResourceProperty_OBJECT,
					},
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "meta",
			},
		},
		{
			Name: "PairExpression",
			Properties: []*model.ResourceProperty{
				{
					Name:    "left",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("Expression"),
				},
				{
					Name:    "right",
					Type:    model.ResourceProperty_STRUCT,
					TypeRef: util.Pointer("Expression"),
				},
			},

			Annotations: map[string]string{
				"OpenApiGroup": "meta",
				"EnableAudit":  "true",
			},
		},
		{
			Name: "Expression",
			Properties: []*model.ResourceProperty{
				{
					Name: "property",
					Type: model.ResourceProperty_STRING,
				},
				{
					Name: "value",
					Type: model.ResourceProperty_OBJECT,
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "meta",
			},
		},
	},
	Properties: []*model.ResourceProperty{
		{
			Name:         "id",
			Type:         model.ResourceProperty_UUID,
			Primary:      true,
			Required:     true,
			Immutable:    true,
			ExampleValue: structpb.NewStringValue("a39621a4-6d48-11ee-b962-0242ac120002"),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:         "version",
			Type:         model.ResourceProperty_INT32,
			Required:     true,
			DefaultValue: structpb.NewNumberValue(1),
			ExampleValue: structpb.NewNumberValue(1),

			Annotations: map[string]string{
				"SpecialProperty":     "true",
				"AllowEmptyPrimitive": "true",
			},
		},
		{
			Name:         "auditData",
			Type:         model.ResourceProperty_STRUCT,
			TypeRef:      util.Pointer("AuditData"),
			ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"createdBy": structpb.NewStringValue("admin"), "updatedBy": structpb.NewStringValue("admin"), "createdOn": structpb.NewStringValue("2024-05-03T21:31:07+04:00"), "updatedOn": structpb.NewStringValue("2024-05-03T21:31:07+04:00")}}),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:         "namespace",
			Type:         model.ResourceProperty_STRING,
			Length:       255,
			ExampleValue: structpb.NewStringValue("default"),
		},
		{
			Name:         "resource",
			Type:         model.ResourceProperty_STRING,
			Length:       255,
			ExampleValue: structpb.NewStringValue("Book"),
		},
		{
			Name:    "recordSelector",
			Type:    model.ResourceProperty_STRUCT,
			TypeRef: util.Pointer("BooleanExpression"),
		},
		{
			Name:         "operation",
			Type:         model.ResourceProperty_ENUM,
			Length:       255,
			Required:     true,
			DefaultValue: structpb.NewStringValue("FULL"),
			ExampleValue: structpb.NewStringValue("READ"),
			EnumValues:   []string{"READ", "CREATE", "UPDATE", "DELETE", "FULL"},
		},
		{
			Name: "before",
			Type: model.ResourceProperty_TIMESTAMP,
		},
		{
			Name: "after",
			Type: model.ResourceProperty_TIMESTAMP,
		},
		{
			Name:      "user",
			Type:      model.ResourceProperty_REFERENCE,
			Reference: &model.Reference{Resource: "User", Namespace: "system"},
		},
		{
			Name:      "role",
			Type:      model.ResourceProperty_REFERENCE,
			Reference: &model.Reference{Resource: "Role", Namespace: "system"},
		},
		{
			Name:       "permit",
			Type:       model.ResourceProperty_ENUM,
			Length:     255,
			Required:   true,
			EnumValues: []string{"ALLOW", "REJECT"},
		},
		{
			Name: "localFlags",
			Type: model.ResourceProperty_OBJECT,
		},
	},

	Annotations: map[string]string{
		"EnableAudit":  "true",
		"OpenApiGroup": "meta",
	},
}
View Source 
var PropertyMapperInstance = NewPropertyMapper()
View Source 
var RecordMapperInstance = NewRecordMapper()
View Source 
var RecordResource = &model.Resource{
	Name:        "Record",
	Namespace:   "system",
	Title:       util.Pointer("Generic Record"),
	Description: util.Pointer("A generic record resource. All Apis are extended from Generic Record resource"),
	Properties: []*model.ResourceProperty{
		{
			Name:         "id",
			Type:         model.ResourceProperty_UUID,
			Primary:      true,
			Required:     true,
			Immutable:    true,
			ExampleValue: structpb.NewStringValue("a39621a4-6d48-11ee-b962-0242ac120002"),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:     "properties",
			Type:     model.ResourceProperty_OBJECT,
			Required: true,
		},
		{
			Name: "packedProperties",
			Type: model.ResourceProperty_LIST,
			Item: &model.ResourceProperty{
				Name: "",
				Type: model.ResourceProperty_OBJECT,
			},

			Annotations: map[string]string{
				"OpenApiHide": "true",
			},
		},
	},
	Virtual: true,

	Annotations: map[string]string{
		"RestApiDisabled": "true",
	},
}
View Source 
var RecordSearchParamsMapperInstance = NewRecordSearchParamsMapper()
View Source 
var ResourceActionAuditDataMapperInstance = NewResourceActionAuditDataMapper()
View Source 
var ResourceActionMapperInstance = NewResourceActionMapper()
View Source 
var ResourceActionResource = &model.Resource{
	Name:      "ResourceAction",
	Namespace: "system",
	Types: []*model.ResourceSubType{
		{
			Name:        "SubType",
			Title:       "Sub Type",
			Description: "Sub Type is a type that represents a sub type of a resource. It is mostly used by STRUCT type to define the properties of the struct. ",
			Properties: []*model.ResourceProperty{
				{
					Name:         "name",
					Type:         model.ResourceProperty_STRING,
					Required:     true,
					ExampleValue: structpb.NewStringValue("Book"),
				},
				{
					Name:         "title",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("Book"),
				},
				{
					Name:         "description",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("Book is a sub type of Resource. It represents a book in the system. "),
				},
				{
					Name:     "properties",
					Type:     model.ResourceProperty_MAP,
					Required: true,
					Item: &model.ResourceProperty{
						Name:    "",
						Type:    model.ResourceProperty_STRUCT,
						TypeRef: util.Pointer("Property"),
					},
					ExampleValue: structpb.NewListValue(&structpb.ListValue{Values: []*structpb.Value{structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"name": structpb.NewStringValue("title"), "type": structpb.NewStringValue("STRING")}})}}),
				},
			},

			Annotations: map[string]string{
				"EnableAudit":     "true",
				"RestApiDisabled": "true",
				"OpenApiGroup":    "meta",
			},
		},
		{
			Name:        "Property",
			Title:       "Property",
			Description: "Property is a type that represents a property of a resource. It is like an API properties or properties of class in a programming language",
			Properties: []*model.ResourceProperty{
				{
					Name:         "type",
					Type:         model.ResourceProperty_ENUM,
					Required:     true,
					ExampleValue: structpb.NewStringValue("STRING"),
					EnumValues:   []string{"BOOL", "STRING", "FLOAT32", "FLOAT64", "INT32", "INT64", "BYTES", "UUID", "DATE", "TIME", "TIMESTAMP", "OBJECT", "MAP", "LIST", "REFERENCE", "ENUM", "STRUCT"},
				},
				{
					Name:         "typeRef",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("BookPublishingDetails"),
				},
				{
					Name:         "primary",
					Type:         model.ResourceProperty_BOOL,
					Required:     true,
					DefaultValue: nil,
				},
				{
					Name:         "required",
					Type:         model.ResourceProperty_BOOL,
					Required:     true,
					DefaultValue: nil,
				},
				{
					Name:         "unique",
					Type:         model.ResourceProperty_BOOL,
					Required:     true,
					DefaultValue: nil,
				},
				{
					Name:         "immutable",
					Type:         model.ResourceProperty_BOOL,
					Required:     true,
					DefaultValue: nil,
				},
				{
					Name:         "virtual",
					Type:         model.ResourceProperty_BOOL,
					Required:     true,
					DefaultValue: nil,
				},
				{
					Name:         "length",
					Type:         model.ResourceProperty_INT32,
					Required:     true,
					DefaultValue: structpb.NewNumberValue(256),
					ExampleValue: structpb.NewNumberValue(256),
				},
				{
					Name:         "item",
					Type:         model.ResourceProperty_STRUCT,
					TypeRef:      util.Pointer("Property"),
					ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"type": structpb.NewStringValue("STRING")}}),
				},
				{
					Name:         "reference",
					Type:         model.ResourceProperty_STRING,
					ExampleValue: structpb.NewStringValue("Book"),
				},
				{
					Name:         "backReference",
					Type:         model.ResourceProperty_STRING,
					ExampleValue: structpb.NewStringValue("Book"),
				},
				{
					Name:         "defaultValue",
					Type:         model.ResourceProperty_OBJECT,
					ExampleValue: structpb.NewStringValue("Lord of the Rings"),
				},
				{
					Name: "enumValues",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Name: "",
						Type: model.ResourceProperty_STRING,
					},
					ExampleValue: structpb.NewListValue(&structpb.ListValue{Values: []*structpb.Value{structpb.NewStringValue("UNKNOWN"), structpb.NewStringValue("ASC"), structpb.NewStringValue("DESC")}}),
				},
				{
					Name:         "exampleValue",
					Type:         model.ResourceProperty_OBJECT,
					ExampleValue: structpb.NewStringValue("no-book-name"),
				},
				{
					Name:         "title",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("Book Title"),
				},
				{
					Name:         "description",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("Book Title is a property of Book Resource. It represents the title of the book."),
				},
				{
					Name: "annotations",
					Type: model.ResourceProperty_MAP,
					Item: &model.ResourceProperty{
						Name: "",
						Type: model.ResourceProperty_STRING,
					},
					ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"CheckVersion": structpb.NewStringValue("true"), "IgnoreIfExists": structpb.NewStringValue("true"), "CommonType": structpb.NewStringValue("testType")}}),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
			},

			Annotations: map[string]string{
				"EnableAudit":     "true",
				"RestApiDisabled": "true",
				"OpenApiGroup":    "meta",
			},
		},
		{
			Name:        "AuditData",
			Title:       "Audit Data",
			Description: "Audit Data is a type that represents the audit data of a resource/record. ",
			Properties: []*model.ResourceProperty{
				{
					Name:         "createdBy",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					Immutable:    true,
					ExampleValue: structpb.NewStringValue("admin"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "updatedBy",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("admin"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "createdOn",
					Type:         model.ResourceProperty_TIMESTAMP,
					Immutable:    true,
					ExampleValue: structpb.NewStringValue("2024-03-22T17:52:25+04:00"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "updatedOn",
					Type:         model.ResourceProperty_TIMESTAMP,
					ExampleValue: structpb.NewStringValue("2024-03-22T17:52:25+04:00"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
			},

			Annotations: map[string]string{
				"EnableAudit":     "true",
				"RestApiDisabled": "true",
				"OpenApiGroup":    "meta",
			},
		},
	},
	Properties: []*model.ResourceProperty{
		{
			Name:         "id",
			Type:         model.ResourceProperty_UUID,
			Primary:      true,
			Required:     true,
			Immutable:    true,
			ExampleValue: structpb.NewStringValue("a39621a4-6d48-11ee-b962-0242ac120002"),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:         "version",
			Type:         model.ResourceProperty_INT32,
			Required:     true,
			DefaultValue: structpb.NewNumberValue(1),
			ExampleValue: structpb.NewNumberValue(1),

			Annotations: map[string]string{
				"SpecialProperty":     "true",
				"AllowEmptyPrimitive": "true",
			},
		},
		{
			Name:         "auditData",
			Type:         model.ResourceProperty_STRUCT,
			TypeRef:      util.Pointer("AuditData"),
			ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"createdBy": structpb.NewStringValue("admin"), "updatedBy": structpb.NewStringValue("admin"), "createdOn": structpb.NewStringValue("2024-03-22T17:52:25+04:00"), "updatedOn": structpb.NewStringValue("2024-03-22T17:52:25+04:00")}}),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:      "resource",
			Type:      model.ResourceProperty_REFERENCE,
			Required:  true,
			Reference: &model.Reference{Resource: "Resource", Namespace: "system"},
		},
		{
			Name:     "name",
			Type:     model.ResourceProperty_STRING,
			Length:   256,
			Required: true,

			Annotations: map[string]string{
				"IsHclLabel": "true",
			},
		},
		{
			Name:   "title",
			Type:   model.ResourceProperty_STRING,
			Length: 256,

			Annotations: map[string]string{
				"IsHclLabel": "true",
			},
		},
		{
			Name:   "description",
			Type:   model.ResourceProperty_STRING,
			Length: 256,

			Annotations: map[string]string{
				"IsHclLabel": "true",
			},
		},
		{
			Name:         "internal",
			Type:         model.ResourceProperty_BOOL,
			Required:     true,
			DefaultValue: nil,

			Annotations: map[string]string{
				"IsHclLabel": "true",
			},
		},
		{
			Name: "types",
			Type: model.ResourceProperty_LIST,
			Item: &model.ResourceProperty{
				Name:    "",
				Type:    model.ResourceProperty_STRUCT,
				TypeRef: util.Pointer("SubType"),
			},
		},
		{
			Name: "input",
			Type: model.ResourceProperty_MAP,
			Item: &model.ResourceProperty{
				Name:    "",
				Type:    model.ResourceProperty_STRUCT,
				TypeRef: util.Pointer("Property"),
			},
		},
		{
			Name:    "output",
			Type:    model.ResourceProperty_STRUCT,
			TypeRef: util.Pointer("Property"),
		},
		{
			Name: "annotations",
			Type: model.ResourceProperty_MAP,
			Item: &model.ResourceProperty{
				Name: "",
				Type: model.ResourceProperty_STRING,
			},
			ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"CheckVersion": structpb.NewStringValue("true"), "IgnoreIfExists": structpb.NewStringValue("true"), "CommonType": structpb.NewStringValue("testType")}}),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
	},
	Indexes: []*model.ResourceIndex{
		{
			Properties: []*model.ResourceIndexProperty{
				{
					Name:  "resource",
					Order: model.Order_ORDER_UNKNOWN,
				},
				{
					Name:  "name",
					Order: model.Order_ORDER_UNKNOWN,
				},
			},
			IndexType: model.ResourceIndexType_BTREE,
			Unique:    true,
		},
	},

	Annotations: map[string]string{
		"OpenApiGroup":    "meta",
		"EnableAudit":     "true",
		"RestApiDisabled": "true",
	},
}
View Source 
var ResourceAuditDataMapperInstance = NewResourceAuditDataMapper()
View Source 
var ResourceIndexMapperInstance = NewResourceIndexMapper()
View Source 
var ResourceIndexPropertyMapperInstance = NewResourceIndexPropertyMapper()
View Source 
var ResourceMapperInstance = NewResourceMapper()
View Source 
var ResourceResource = &model.Resource{
	Name:        "Resource",
	Namespace:   "system",
	Title:       util.Pointer("Resource"),
	Description: util.Pointer("Resource is a top level resource that represents a model and API in the system"),
	Types: []*model.ResourceSubType{
		{
			Name:        "Property",
			Title:       "Property",
			Description: "Property is a type that represents a property of a resource. It is like an API properties or properties of class in a programming language",
			Properties: []*model.ResourceProperty{
				{
					Name:         "type",
					Type:         model.ResourceProperty_ENUM,
					Required:     true,
					ExampleValue: structpb.NewStringValue("STRING"),
					EnumValues:   []string{"BOOL", "STRING", "FLOAT32", "FLOAT64", "INT32", "INT64", "BYTES", "UUID", "DATE", "TIME", "TIMESTAMP", "OBJECT", "MAP", "LIST", "REFERENCE", "ENUM", "STRUCT"},
				},
				{
					Name:         "typeRef",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("BookPublishingDetails"),
				},
				{
					Name:         "primary",
					Type:         model.ResourceProperty_BOOL,
					Required:     true,
					DefaultValue: nil,
				},
				{
					Name:         "required",
					Type:         model.ResourceProperty_BOOL,
					Required:     true,
					DefaultValue: nil,
				},
				{
					Name:         "unique",
					Type:         model.ResourceProperty_BOOL,
					Required:     true,
					DefaultValue: nil,
				},
				{
					Name:         "immutable",
					Type:         model.ResourceProperty_BOOL,
					Required:     true,
					DefaultValue: nil,
				},
				{
					Name:         "virtual",
					Type:         model.ResourceProperty_BOOL,
					Required:     true,
					DefaultValue: nil,
				},
				{
					Name:         "length",
					Type:         model.ResourceProperty_INT32,
					Required:     true,
					DefaultValue: structpb.NewNumberValue(256),
					ExampleValue: structpb.NewNumberValue(256),
				},
				{
					Name:         "item",
					Type:         model.ResourceProperty_STRUCT,
					TypeRef:      util.Pointer("Property"),
					ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"type": structpb.NewStringValue("STRING")}}),
				},
				{
					Name:         "reference",
					Type:         model.ResourceProperty_STRING,
					ExampleValue: structpb.NewStringValue("Book"),
				},
				{
					Name:         "backReference",
					Type:         model.ResourceProperty_STRING,
					ExampleValue: structpb.NewStringValue("Book"),
				},
				{
					Name:         "defaultValue",
					Type:         model.ResourceProperty_OBJECT,
					ExampleValue: structpb.NewStringValue("Lord of the Rings"),
				},
				{
					Name: "enumValues",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Name: "",
						Type: model.ResourceProperty_STRING,
					},
					ExampleValue: structpb.NewListValue(&structpb.ListValue{Values: []*structpb.Value{structpb.NewStringValue("UNKNOWN"), structpb.NewStringValue("ASC"), structpb.NewStringValue("DESC")}}),
				},
				{
					Name:         "exampleValue",
					Type:         model.ResourceProperty_OBJECT,
					ExampleValue: structpb.NewStringValue("no-book-name"),
				},
				{
					Name:         "title",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("Book Title"),
				},
				{
					Name:         "description",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("Book Title is a property of Book Resource. It represents the title of the book."),
				},
				{
					Name: "annotations",
					Type: model.ResourceProperty_MAP,
					Item: &model.ResourceProperty{
						Name: "",
						Type: model.ResourceProperty_STRING,
					},
					ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"CheckVersion": structpb.NewStringValue("true"), "IgnoreIfExists": structpb.NewStringValue("true"), "CommonType": structpb.NewStringValue("testType")}}),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
			},

			Annotations: map[string]string{
				"RestApiDisabled": "true",
				"OpenApiGroup":    "meta",
				"OpenApiRestPath": "resources",
				"EnableAudit":     "true",
			},
		},
		{
			Name:        "SubType",
			Title:       "Sub Type",
			Description: "Sub Type is a type that represents a sub type of a resource. It is mostly used by STRUCT type to define the properties of the struct. ",
			Properties: []*model.ResourceProperty{
				{
					Name:         "name",
					Type:         model.ResourceProperty_STRING,
					Required:     true,
					ExampleValue: structpb.NewStringValue("Book"),
				},
				{
					Name:         "title",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("Book"),
				},
				{
					Name:         "description",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("Book is a sub type of Resource. It represents a book in the system. "),
				},
				{
					Name:     "properties",
					Type:     model.ResourceProperty_MAP,
					Required: true,
					Item: &model.ResourceProperty{
						Name:    "",
						Type:    model.ResourceProperty_STRUCT,
						TypeRef: util.Pointer("Property"),
					},
					ExampleValue: structpb.NewListValue(&structpb.ListValue{Values: []*structpb.Value{structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"name": structpb.NewStringValue("title"), "type": structpb.NewStringValue("STRING")}})}}),
				},
			},

			Annotations: map[string]string{
				"EnableAudit":     "true",
				"RestApiDisabled": "true",
				"OpenApiGroup":    "meta",
				"OpenApiRestPath": "resources",
			},
		},
		{
			Name:        "AuditData",
			Title:       "Audit Data",
			Description: "Audit Data is a type that represents the audit data of a resource/record. ",
			Properties: []*model.ResourceProperty{
				{
					Name:         "createdBy",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					Immutable:    true,
					ExampleValue: structpb.NewStringValue("admin"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "updatedBy",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("admin"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "createdOn",
					Type:         model.ResourceProperty_TIMESTAMP,
					Immutable:    true,
					ExampleValue: structpb.NewStringValue("2024-05-03T21:31:07+04:00"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "updatedOn",
					Type:         model.ResourceProperty_TIMESTAMP,
					ExampleValue: structpb.NewStringValue("2024-05-03T21:31:07+04:00"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
			},

			Annotations: map[string]string{
				"EnableAudit":     "true",
				"RestApiDisabled": "true",
				"OpenApiGroup":    "meta",
				"OpenApiRestPath": "resources",
			},
		},
		{
			Name: "IndexProperty",
			Properties: []*model.ResourceProperty{
				{
					Name:     "name",
					Type:     model.ResourceProperty_STRING,
					Required: true,
				},
				{
					Name:         "order",
					Type:         model.ResourceProperty_ENUM,
					DefaultValue: structpb.NewStringValue("ASC"),
					EnumValues:   []string{"UNKNOWN", "ASC", "DESC"},
				},
			},

			Annotations: map[string]string{
				"EnableAudit":     "true",
				"RestApiDisabled": "true",
				"OpenApiGroup":    "meta",
				"OpenApiRestPath": "resources",
			},
		},
		{
			Name: "Index",
			Properties: []*model.ResourceProperty{
				{
					Name: "properties",
					Type: model.ResourceProperty_LIST,
					Item: &model.ResourceProperty{
						Name:    "",
						Type:    model.ResourceProperty_STRUCT,
						TypeRef: util.Pointer("IndexProperty"),
					},
				},
				{
					Name:         "indexType",
					Type:         model.ResourceProperty_ENUM,
					DefaultValue: structpb.NewStringValue("BTREE"),
					EnumValues:   []string{"BTREE", "HASH"},
				},
				{
					Name: "unique",
					Type: model.ResourceProperty_BOOL,
				},
				{
					Name: "annotations",
					Type: model.ResourceProperty_MAP,
					Item: &model.ResourceProperty{
						Name: "",
						Type: model.ResourceProperty_STRING,
					},
					ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"CheckVersion": structpb.NewStringValue("true"), "IgnoreIfExists": structpb.NewStringValue("true"), "CommonType": structpb.NewStringValue("testType")}}),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
			},

			Annotations: map[string]string{
				"OpenApiRestPath": "resources",
				"EnableAudit":     "true",
				"RestApiDisabled": "true",
				"OpenApiGroup":    "meta",
			},
		},
	},
	Properties: []*model.ResourceProperty{
		{
			Name:         "id",
			Type:         model.ResourceProperty_UUID,
			Primary:      true,
			Required:     true,
			Immutable:    true,
			ExampleValue: structpb.NewStringValue("a39621a4-6d48-11ee-b962-0242ac120002"),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:         "version",
			Type:         model.ResourceProperty_INT32,
			Required:     true,
			DefaultValue: structpb.NewNumberValue(1),
			ExampleValue: structpb.NewNumberValue(1),

			Annotations: map[string]string{
				"AllowEmptyPrimitive": "true",
				"SpecialProperty":     "true",
			},
		},
		{
			Name:         "auditData",
			Type:         model.ResourceProperty_STRUCT,
			TypeRef:      util.Pointer("AuditData"),
			ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"createdBy": structpb.NewStringValue("admin"), "updatedBy": structpb.NewStringValue("admin"), "createdOn": structpb.NewStringValue("2024-05-03T21:31:07+04:00"), "updatedOn": structpb.NewStringValue("2024-05-03T21:31:07+04:00")}}),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:         "name",
			Type:         model.ResourceProperty_STRING,
			Length:       256,
			Required:     true,
			ExampleValue: structpb.NewStringValue("Book"),

			Annotations: map[string]string{
				"IsHclLabel": "true",
			},
		},
		{
			Name:         "namespace",
			Type:         model.ResourceProperty_REFERENCE,
			Required:     true,
			DefaultValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"name": structpb.NewStringValue("default")}}),
			Reference:    &model.Reference{Resource: "Namespace", Namespace: "system"},
			ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"name": structpb.NewStringValue("default")}}),
		},
		{
			Name:         "virtual",
			Type:         model.ResourceProperty_BOOL,
			Required:     true,
			DefaultValue: nil,
		},
		{
			Name:     "properties",
			Type:     model.ResourceProperty_MAP,
			Required: true,
			Item: &model.ResourceProperty{
				Name:    "",
				Type:    model.ResourceProperty_STRUCT,
				TypeRef: util.Pointer("Property"),
			},
			ExampleValue: structpb.NewListValue(&structpb.ListValue{Values: []*structpb.Value{structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"name": structpb.NewStringValue("title"), "type": structpb.NewStringValue("name")}}), structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"name": structpb.NewStringValue("type"), "type": structpb.NewStringValue("STRING")}})}}),
		},
		{
			Name: "indexes",
			Type: model.ResourceProperty_LIST,
			Item: &model.ResourceProperty{
				Name:    "",
				Type:    model.ResourceProperty_STRUCT,
				TypeRef: util.Pointer("Index"),
			},
		},
		{
			Name: "types",
			Type: model.ResourceProperty_LIST,
			Item: &model.ResourceProperty{
				Name:    "",
				Type:    model.ResourceProperty_STRUCT,
				TypeRef: util.Pointer("SubType"),
			},
		},
		{
			Name:         "immutable",
			Type:         model.ResourceProperty_BOOL,
			Required:     true,
			DefaultValue: nil,
		},
		{
			Name:         "abstract",
			Type:         model.ResourceProperty_BOOL,
			Required:     true,
			DefaultValue: nil,
		},
		{
			Name:         "checkReferences",
			Type:         model.ResourceProperty_BOOL,
			Required:     true,
			DefaultValue: nil,
		},
		{
			Name:      "dataSource",
			Type:      model.ResourceProperty_REFERENCE,
			Reference: &model.Reference{Resource: "DataSource", Namespace: "system"},
		},
		{
			Name:         "entity",
			Type:         model.ResourceProperty_STRING,
			Length:       256,
			ExampleValue: structpb.NewStringValue("book"),
		},
		{
			Name:         "catalog",
			Type:         model.ResourceProperty_STRING,
			Length:       256,
			ExampleValue: structpb.NewStringValue("public"),
		},
		{
			Name:         "title",
			Type:         model.ResourceProperty_STRING,
			Length:       256,
			ExampleValue: structpb.NewStringValue("Book"),
		},
		{
			Name:         "description",
			Type:         model.ResourceProperty_STRING,
			Length:       256,
			ExampleValue: structpb.NewStringValue("Book is a resource in the system. It represents a book in the system."),
		},
		{
			Name: "annotations",
			Type: model.ResourceProperty_MAP,
			Item: &model.ResourceProperty{
				Name: "",
				Type: model.ResourceProperty_STRING,
			},
			ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"CheckVersion": structpb.NewStringValue("true"), "IgnoreIfExists": structpb.NewStringValue("true"), "CommonType": structpb.NewStringValue("testType")}}),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
	},
	Indexes: []*model.ResourceIndex{
		{
			Properties: []*model.ResourceIndexProperty{
				{
					Name:  "namespace",
					Order: model.Order_ORDER_UNKNOWN,
				},
				{
					Name:  "name",
					Order: model.Order_ORDER_UNKNOWN,
				},
			},
			IndexType: model.ResourceIndexType_BTREE,
			Unique:    true,
		},
	},

	Annotations: map[string]string{
		"EnableAudit":     "true",
		"RestApiDisabled": "true",
		"OpenApiGroup":    "meta",
		"OpenApiRestPath": "resources",
	},
}
View Source 
var RoleAuditDataMapperInstance = NewRoleAuditDataMapper()
View Source 
var RoleMapperInstance = NewRoleMapper()
View Source 
var RoleResource = &model.Resource{
	Name:        "Role",
	Namespace:   "system",
	Title:       util.Pointer("Role"),
	Description: util.Pointer("Role is a resource that defines the access control model. It is used to give permissions to users in a grouped way"),
	Types: []*model.ResourceSubType{
		{
			Name:        "AuditData",
			Title:       "Audit Data",
			Description: "Audit Data is a type that represents the audit data of a resource/record. ",
			Properties: []*model.ResourceProperty{
				{
					Name:         "createdBy",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					Immutable:    true,
					ExampleValue: structpb.NewStringValue("admin"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "updatedBy",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("admin"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "createdOn",
					Type:         model.ResourceProperty_TIMESTAMP,
					Immutable:    true,
					ExampleValue: structpb.NewStringValue("2024-05-03T21:31:07+04:00"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "updatedOn",
					Type:         model.ResourceProperty_TIMESTAMP,
					ExampleValue: structpb.NewStringValue("2024-05-03T21:31:07+04:00"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "meta",
			},
		},
	},
	Properties: []*model.ResourceProperty{
		{
			Name:         "id",
			Type:         model.ResourceProperty_UUID,
			Primary:      true,
			Required:     true,
			Immutable:    true,
			ExampleValue: structpb.NewStringValue("a39621a4-6d48-11ee-b962-0242ac120002"),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:         "version",
			Type:         model.ResourceProperty_INT32,
			Required:     true,
			DefaultValue: structpb.NewNumberValue(1),
			ExampleValue: structpb.NewNumberValue(1),

			Annotations: map[string]string{
				"SpecialProperty":     "true",
				"AllowEmptyPrimitive": "true",
			},
		},
		{
			Name:         "auditData",
			Type:         model.ResourceProperty_STRUCT,
			TypeRef:      util.Pointer("AuditData"),
			ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"updatedOn": structpb.NewStringValue("2024-05-03T21:31:07+04:00"), "createdBy": structpb.NewStringValue("admin"), "updatedBy": structpb.NewStringValue("admin"), "createdOn": structpb.NewStringValue("2024-05-03T21:31:07+04:00")}}),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:     "name",
			Type:     model.ResourceProperty_STRING,
			Length:   256,
			Required: true,
			Unique:   true,

			Annotations: map[string]string{
				"IsHclLabel": "true",
			},
		},
		{
			Name: "permissions",
			Type: model.ResourceProperty_LIST,
			Item: &model.ResourceProperty{
				Name:      "",
				Type:      model.ResourceProperty_REFERENCE,
				Reference: &model.Reference{Resource: "Permission", Namespace: "system"},
			},
		},
		{
			Name: "details",
			Type: model.ResourceProperty_OBJECT,
		},
	},

	Annotations: map[string]string{
		"EnableAudit":  "true",
		"OpenApiGroup": "meta",
	},
}
View Source 
var SubTypeMapperInstance = NewSubTypeMapper()
View Source 
var UserAuditDataMapperInstance = NewUserAuditDataMapper()
View Source 
var UserMapperInstance = NewUserMapper()
View Source 
var UserResource = &model.Resource{
	Name:        "User",
	Namespace:   "system",
	Title:       util.Pointer("User"),
	Description: util.Pointer("User is a resource that defines the access control model. It is used to authenticate and authorize users."),
	Types: []*model.ResourceSubType{
		{
			Name:        "AuditData",
			Title:       "Audit Data",
			Description: "Audit Data is a type that represents the audit data of a resource/record. ",
			Properties: []*model.ResourceProperty{
				{
					Name:         "createdBy",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					Immutable:    true,
					ExampleValue: structpb.NewStringValue("admin"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "updatedBy",
					Type:         model.ResourceProperty_STRING,
					Length:       256,
					ExampleValue: structpb.NewStringValue("admin"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "createdOn",
					Type:         model.ResourceProperty_TIMESTAMP,
					Immutable:    true,
					ExampleValue: structpb.NewStringValue("2024-05-03T21:31:07+04:00"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
				{
					Name:         "updatedOn",
					Type:         model.ResourceProperty_TIMESTAMP,
					ExampleValue: structpb.NewStringValue("2024-05-03T21:31:07+04:00"),

					Annotations: map[string]string{
						"SpecialProperty": "true",
					},
				},
			},

			Annotations: map[string]string{
				"EnableAudit":  "true",
				"OpenApiGroup": "meta",
			},
		},
	},
	Properties: []*model.ResourceProperty{
		{
			Name:         "id",
			Type:         model.ResourceProperty_UUID,
			Primary:      true,
			Required:     true,
			Immutable:    true,
			ExampleValue: structpb.NewStringValue("a39621a4-6d48-11ee-b962-0242ac120002"),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:         "version",
			Type:         model.ResourceProperty_INT32,
			Required:     true,
			DefaultValue: structpb.NewNumberValue(1),
			ExampleValue: structpb.NewNumberValue(1),

			Annotations: map[string]string{
				"SpecialProperty":     "true",
				"AllowEmptyPrimitive": "true",
			},
		},
		{
			Name:         "auditData",
			Type:         model.ResourceProperty_STRUCT,
			TypeRef:      util.Pointer("AuditData"),
			ExampleValue: structpb.NewStructValue(&structpb.Struct{Fields: map[string]*structpb.Value{"createdBy": structpb.NewStringValue("admin"), "updatedBy": structpb.NewStringValue("admin"), "createdOn": structpb.NewStringValue("2024-05-03T21:31:07+04:00"), "updatedOn": structpb.NewStringValue("2024-05-03T21:31:07+04:00")}}),

			Annotations: map[string]string{
				"SpecialProperty": "true",
			},
		},
		{
			Name:     "username",
			Type:     model.ResourceProperty_STRING,
			Length:   256,
			Required: true,
			Unique:   true,

			Annotations: map[string]string{
				"IsHclLabel": "true",
			},
		},
		{
			Name:   "password",
			Type:   model.ResourceProperty_STRING,
			Length: 256,
		},
		{
			Name: "roles",
			Type: model.ResourceProperty_LIST,
			Item: &model.ResourceProperty{
				Name:      "",
				Type:      model.ResourceProperty_REFERENCE,
				Reference: &model.Reference{Resource: "Role", Namespace: "system"},
			},
		},
		{
			Name: "permissions",
			Type: model.ResourceProperty_LIST,
			Item: &model.ResourceProperty{
				Name:      "",
				Type:      model.ResourceProperty_REFERENCE,
				Reference: &model.Reference{Resource: "Permission", Namespace: "system"},
			},
		},
		{
			Name: "details",
			Type: model.ResourceProperty_OBJECT,
		},
	},

	Annotations: map[string]string{
		"EnableAudit":  "true",
		"OpenApiGroup": "meta",
	},
}

Functions

This section is empty.

Types

type AuditLog added in v1.1.90 

type AuditLog struct {
	Id          *uuid.UUID        `json:"id,omitempty"`
	Version     int32             `json:"version,omitempty"`
	Namespace   string            `json:"namespace,omitempty"`
	Resource    string            `json:"resource,omitempty"`
	RecordId    string            `json:"recordId,omitempty"`
	Time        time.Time         `json:"time,omitempty"`
	Username    string            `json:"username,omitempty"`
	Operation   AuditLogOperation `json:"operation,omitempty"`
	Properties  interface{}       `json:"properties,omitempty"`
	Annotations map[string]string `json:"annotations,omitempty"`
}

func (AuditLog) GetAnnotations added in v1.1.90 

func (s AuditLog) GetAnnotations() map[string]string

func (AuditLog) GetId added in v1.1.90 

func (s AuditLog) GetId() *uuid.UUID

func (AuditLog) GetNamespace added in v1.1.90 

func (s AuditLog) GetNamespace() string

func (AuditLog) GetOperation added in v1.1.90 

func (s AuditLog) GetOperation() AuditLogOperation

func (AuditLog) GetProperties added in v1.2.21 

func (s AuditLog) GetProperties() interface{}

func (AuditLog) GetRecordId added in v1.1.90 

func (s AuditLog) GetRecordId() string

func (AuditLog) GetResource added in v1.1.90 

func (s AuditLog) GetResource() string

func (AuditLog) GetTime added in v1.1.90 

func (s AuditLog) GetTime() time.Time

func (AuditLog) GetUsername added in v1.1.90 

func (s AuditLog) GetUsername() string

func (AuditLog) GetVersion added in v1.1.90 

func (s AuditLog) GetVersion() int32

type AuditLogMapper added in v1.1.90 

type AuditLogMapper struct {
}

func NewAuditLogMapper added in v1.1.90 

func NewAuditLogMapper() *AuditLogMapper

func (*AuditLogMapper) FromProperties added in v1.1.90 

func (m *AuditLogMapper) FromProperties(properties map[string]*structpb.Value) *AuditLog

func (*AuditLogMapper) FromRecord added in v1.1.90 

func (m *AuditLogMapper) FromRecord(record *model.Record) *AuditLog

func (*AuditLogMapper) New added in v1.1.90 

func (m *AuditLogMapper) New() *AuditLog

func (*AuditLogMapper) ResourceIdentity added in v1.1.90 

func (m *AuditLogMapper) ResourceIdentity() abs.ResourceIdentity

func (*AuditLogMapper) ToProperties added in v1.1.90 

func (m *AuditLogMapper) ToProperties(auditLog *AuditLog) map[string]*structpb.Value

func (*AuditLogMapper) ToRecord added in v1.1.90 

func (m *AuditLogMapper) ToRecord(auditLog *AuditLog) *model.Record

func (*AuditLogMapper) ToUnstructured added in v1.3.43 

func (m *AuditLogMapper) ToUnstructured(auditLog *AuditLog) unstructured.Unstructured

type AuditLogOperation added in v1.1.90 

type AuditLogOperation string
const (
	AuditLogOperation_CREATE AuditLogOperation = "CREATE"
	AuditLogOperation_UPDATE AuditLogOperation = "UPDATE"
	AuditLogOperation_DELETE AuditLogOperation = "DELETE"
)

type BooleanExpression added in v1.2.39 

type BooleanExpression struct {
	And                []BooleanExpression    `json:"and,omitempty"`
	Or                 []BooleanExpression    `json:"or,omitempty"`
	Not                *BooleanExpression     `json:"not,omitempty"`
	Equal              *PairExpression        `json:"equal,omitempty"`
	LessThan           *PairExpression        `json:"lessThan,omitempty"`
	GreaterThan        *PairExpression        `json:"greaterThan,omitempty"`
	LessThanOrEqual    *PairExpression        `json:"lessThanOrEqual,omitempty"`
	GreaterThanOrEqual *PairExpression        `json:"greaterThanOrEqual,omitempty"`
	In                 *PairExpression        `json:"in,omitempty"`
	Like               *PairExpression        `json:"like,omitempty"`
	Ilike              *PairExpression        `json:"ilike,omitempty"`
	Regex              *PairExpression        `json:"regex,omitempty"`
	IsNull             *Expression            `json:"isNull,omitempty"`
	Filters            map[string]interface{} `json:"filters,omitempty"`
}

func (BooleanExpression) GetAnd added in v1.2.39 

func (s BooleanExpression) GetAnd() []BooleanExpression

func (BooleanExpression) GetEqual added in v1.2.39 

func (s BooleanExpression) GetEqual() *PairExpression

func (BooleanExpression) GetFilters added in v1.3.95 

func (s BooleanExpression) GetFilters() map[string]interface{}

func (BooleanExpression) GetGreaterThan added in v1.2.39 

func (s BooleanExpression) GetGreaterThan() *PairExpression

func (BooleanExpression) GetGreaterThanOrEqual added in v1.2.39 

func (s BooleanExpression) GetGreaterThanOrEqual() *PairExpression

func (BooleanExpression) GetIlike added in v1.4.17 

func (s BooleanExpression) GetIlike() *PairExpression

func (BooleanExpression) GetIn added in v1.2.39 

func (s BooleanExpression) GetIn() *PairExpression

func (BooleanExpression) GetIsNull added in v1.2.39 

func (s BooleanExpression) GetIsNull() *Expression

func (BooleanExpression) GetLessThan added in v1.2.39 

func (s BooleanExpression) GetLessThan() *PairExpression

func (BooleanExpression) GetLessThanOrEqual added in v1.2.39 

func (s BooleanExpression) GetLessThanOrEqual() *PairExpression

func (BooleanExpression) GetLike added in v1.4.17 

func (s BooleanExpression) GetLike() *PairExpression

func (BooleanExpression) GetNot added in v1.2.39 

func (s BooleanExpression) GetNot() *BooleanExpression

func (BooleanExpression) GetOr added in v1.2.39 

func (s BooleanExpression) GetOr() []BooleanExpression

func (BooleanExpression) GetRegex added in v1.4.17 

func (s BooleanExpression) GetRegex() *PairExpression

type BooleanExpressionMapper added in v1.2.39 

type BooleanExpressionMapper struct {
}

func NewBooleanExpressionMapper added in v1.2.39 

func NewBooleanExpressionMapper() *BooleanExpressionMapper

func (*BooleanExpressionMapper) FromProperties added in v1.2.39 

func (m *BooleanExpressionMapper) FromProperties(properties map[string]*structpb.Value) *BooleanExpression

func (*BooleanExpressionMapper) New added in v1.2.39 

func (m *BooleanExpressionMapper) New() *BooleanExpression

func (*BooleanExpressionMapper) ResourceIdentity added in v1.2.39 

func (m *BooleanExpressionMapper) ResourceIdentity() abs.ResourceIdentity

func (*BooleanExpressionMapper) ToProperties added in v1.2.39 

func (m *BooleanExpressionMapper) ToProperties(booleanExpression *BooleanExpression) map[string]*structpb.Value

func (*BooleanExpressionMapper) ToUnstructured added in v1.3.43 

func (m *BooleanExpressionMapper) ToUnstructured(booleanExpression *BooleanExpression) unstructured.Unstructured

type ChannelCall added in v1.2.21 

type ChannelCall struct {
	ChannelKey string `json:"channelKey,omitempty"`
}

func (ChannelCall) GetChannelKey added in v1.2.21 

func (s ChannelCall) GetChannelKey() string

type ChannelCallMapper added in v1.2.21 

type ChannelCallMapper struct {
}

func NewChannelCallMapper added in v1.2.21 

func NewChannelCallMapper() *ChannelCallMapper

func (*ChannelCallMapper) FromProperties added in v1.2.21 

func (m *ChannelCallMapper) FromProperties(properties map[string]*structpb.Value) *ChannelCall

func (*ChannelCallMapper) New added in v1.2.21 

func (m *ChannelCallMapper) New() *ChannelCall

func (*ChannelCallMapper) ResourceIdentity added in v1.2.21 

func (m *ChannelCallMapper) ResourceIdentity() abs.ResourceIdentity

func (*ChannelCallMapper) ToProperties added in v1.2.21 

func (m *ChannelCallMapper) ToProperties(channelCall *ChannelCall) map[string]*structpb.Value

func (*ChannelCallMapper) ToUnstructured added in v1.3.43 

func (m *ChannelCallMapper) ToUnstructured(channelCall *ChannelCall) unstructured.Unstructured

type DataSource 

type DataSource struct {
	Id          *uuid.UUID           `json:"id,omitempty"`
	Version     int32                `json:"version,omitempty"`
	AuditData   *DataSourceAuditData `json:"auditData,omitempty"`
	Name        string               `json:"name,omitempty"`
	Description string               `json:"description,omitempty"`
	Backend     string               `json:"backend,omitempty"`
	Options     map[string]string    `json:"options,omitempty"`
}

func (DataSource) GetAuditData added in v1.2.36 

func (s DataSource) GetAuditData() *DataSourceAuditData

func (DataSource) GetBackend 

func (s DataSource) GetBackend() string

func (DataSource) GetDescription 

func (s DataSource) GetDescription() string

func (DataSource) GetId 

func (s DataSource) GetId() *uuid.UUID

func (DataSource) GetName 

func (s DataSource) GetName() string

func (DataSource) GetOptions 

func (s DataSource) GetOptions() map[string]string

func (DataSource) GetVersion 

func (s DataSource) GetVersion() int32

type DataSourceAuditData added in v1.2.36 

type DataSourceAuditData struct {
	CreatedBy *string    `json:"createdBy,omitempty"`
	UpdatedBy *string    `json:"updatedBy,omitempty"`
	CreatedOn *time.Time `json:"createdOn,omitempty"`
	UpdatedOn *time.Time `json:"updatedOn,omitempty"`
}

func (DataSourceAuditData) GetCreatedBy added in v1.2.36 

func (s DataSourceAuditData) GetCreatedBy() *string

func (DataSourceAuditData) GetCreatedOn added in v1.2.36 

func (s DataSourceAuditData) GetCreatedOn() *time.Time

func (DataSourceAuditData) GetUpdatedBy added in v1.2.36 

func (s DataSourceAuditData) GetUpdatedBy() *string

func (DataSourceAuditData) GetUpdatedOn added in v1.2.36 

func (s DataSourceAuditData) GetUpdatedOn() *time.Time

type DataSourceAuditDataMapper added in v1.2.36 

type DataSourceAuditDataMapper struct {
}

func NewDataSourceAuditDataMapper added in v1.2.36 

func NewDataSourceAuditDataMapper() *DataSourceAuditDataMapper

func (*DataSourceAuditDataMapper) FromProperties added in v1.2.36 

func (m *DataSourceAuditDataMapper) FromProperties(properties map[string]*structpb.Value) *DataSourceAuditData

func (*DataSourceAuditDataMapper) New added in v1.2.36 

func (m *DataSourceAuditDataMapper) New() *DataSourceAuditData

func (*DataSourceAuditDataMapper) ResourceIdentity added in v1.2.36 

func (m *DataSourceAuditDataMapper) ResourceIdentity() abs.ResourceIdentity

func (*DataSourceAuditDataMapper) ToProperties added in v1.2.36 

func (m *DataSourceAuditDataMapper) ToProperties(dataSourceAuditData *DataSourceAuditData) map[string]*structpb.Value

func (*DataSourceAuditDataMapper) ToUnstructured added in v1.3.43 

func (m *DataSourceAuditDataMapper) ToUnstructured(dataSourceAuditData *DataSourceAuditData) unstructured.Unstructured

type DataSourceMapper 

type DataSourceMapper struct {
}

func NewDataSourceMapper 

func NewDataSourceMapper() *DataSourceMapper

func (*DataSourceMapper) FromProperties 

func (m *DataSourceMapper) FromProperties(properties map[string]*structpb.Value) *DataSource

func (*DataSourceMapper) FromRecord 

func (m *DataSourceMapper) FromRecord(record *model.Record) *DataSource

func (*DataSourceMapper) New 

func (m *DataSourceMapper) New() *DataSource

func (*DataSourceMapper) ResourceIdentity 

func (m *DataSourceMapper) ResourceIdentity() abs.ResourceIdentity

func (*DataSourceMapper) ToProperties 

func (m *DataSourceMapper) ToProperties(dataSource *DataSource) map[string]*structpb.Value

func (*DataSourceMapper) ToRecord 

func (m *DataSourceMapper) ToRecord(dataSource *DataSource) *model.Record

func (*DataSourceMapper) ToUnstructured added in v1.3.43 

func (m *DataSourceMapper) ToUnstructured(dataSource *DataSource) unstructured.Unstructured

type Error added in v1.2.21 

type Error struct {
	Code    *ExtensionCode `json:"code,omitempty"`
	Message *string        `json:"message,omitempty"`
	Fields  []ErrorField   `json:"fields,omitempty"`
}

func (Error) GetCode added in v1.2.21 

func (s Error) GetCode() *ExtensionCode

func (Error) GetFields added in v1.2.21 

func (s Error) GetFields() []ErrorField

func (Error) GetMessage added in v1.2.21 

func (s Error) GetMessage() *string

type ErrorField added in v1.2.21 

type ErrorField struct {
	RecordId *string     `json:"recordId,omitempty"`
	Property *string     `json:"property,omitempty"`
	Message  *string     `json:"message,omitempty"`
	Value    interface{} `json:"value,omitempty"`
}

func (ErrorField) GetMessage added in v1.2.21 

func (s ErrorField) GetMessage() *string

func (ErrorField) GetProperty added in v1.2.21 

func (s ErrorField) GetProperty() *string

func (ErrorField) GetRecordId added in v1.2.21 

func (s ErrorField) GetRecordId() *string

func (ErrorField) GetValue added in v1.2.21 

func (s ErrorField) GetValue() interface{}

type ErrorFieldMapper added in v1.2.21 

type ErrorFieldMapper struct {
}

func NewErrorFieldMapper added in v1.2.21 

func NewErrorFieldMapper() *ErrorFieldMapper

func (*ErrorFieldMapper) FromProperties added in v1.2.21 

func (m *ErrorFieldMapper) FromProperties(properties map[string]*structpb.Value) *ErrorField

func (*ErrorFieldMapper) New added in v1.2.21 

func (m *ErrorFieldMapper) New() *ErrorField

func (*ErrorFieldMapper) ResourceIdentity added in v1.2.21 

func (m *ErrorFieldMapper) ResourceIdentity() abs.ResourceIdentity

func (*ErrorFieldMapper) ToProperties added in v1.2.21 

func (m *ErrorFieldMapper) ToProperties(errorField *ErrorField) map[string]*structpb.Value

func (*ErrorFieldMapper) ToUnstructured added in v1.3.43 

func (m *ErrorFieldMapper) ToUnstructured(errorField *ErrorField) unstructured.Unstructured

type ErrorMapper added in v1.2.21 

type ErrorMapper struct {
}

func NewErrorMapper added in v1.2.21 

func NewErrorMapper() *ErrorMapper

func (*ErrorMapper) FromProperties added in v1.2.21 

func (m *ErrorMapper) FromProperties(properties map[string]*structpb.Value) *Error

func (*ErrorMapper) New added in v1.2.21 

func (m *ErrorMapper) New() *Error

func (*ErrorMapper) ResourceIdentity added in v1.2.21 

func (m *ErrorMapper) ResourceIdentity() abs.ResourceIdentity

func (*ErrorMapper) ToProperties added in v1.2.21 

func (m *ErrorMapper) ToProperties(error_ *Error) map[string]*structpb.Value

func (*ErrorMapper) ToUnstructured added in v1.3.43 

func (m *ErrorMapper) ToUnstructured(error_ *Error) unstructured.Unstructured

type Event added in v1.2.21 

type Event struct {
	Id                 string              `json:"id,omitempty"`
	Action             ExtensionAction     `json:"action,omitempty"`
	RecordSearchParams *RecordSearchParams `json:"recordSearchParams,omitempty"`
	Resource           *Resource           `json:"resource,omitempty"`
	Records            []*Record           `json:"records,omitempty"`
	Finalizes          *bool               `json:"finalizes,omitempty"`
	Sync               *bool               `json:"sync,omitempty"`
	Time               *time.Time          `json:"time,omitempty"`
	Total              *int64              `json:"total,omitempty"`
	Annotations        map[string]string   `json:"annotations,omitempty"`
	Error              *Error              `json:"error,omitempty"`
}

func (Event) GetAction added in v1.2.21 

func (s Event) GetAction() ExtensionAction

func (Event) GetAnnotations added in v1.2.21 

func (s Event) GetAnnotations() map[string]string

func (Event) GetError added in v1.2.21 

func (s Event) GetError() *Error

func (Event) GetFinalizes added in v1.2.21 

func (s Event) GetFinalizes() *bool

func (Event) GetId added in v1.2.21 

func (s Event) GetId() string

func (Event) GetRecordSearchParams added in v1.2.21 

func (s Event) GetRecordSearchParams() *RecordSearchParams

func (Event) GetRecords added in v1.2.21 

func (s Event) GetRecords() []*Record

func (Event) GetResource added in v1.2.21 

func (s Event) GetResource() *Resource

func (Event) GetSync added in v1.2.21 

func (s Event) GetSync() *bool

func (Event) GetTime added in v1.2.21 

func (s Event) GetTime() *time.Time

func (Event) GetTotal added in v1.2.21 

func (s Event) GetTotal() *int64

type EventAction 

type EventAction string
const (
	EventAction_CREATE  EventAction = "CREATE"
	EventAction_UPDATE  EventAction = "UPDATE"
	EventAction_DELETE  EventAction = "DELETE"
	EventAction_GET     EventAction = "GET"
	EventAction_LIST    EventAction = "LIST"
	EventAction_OPERATE EventAction = "OPERATE"
)

type EventMapper added in v1.2.21 

type EventMapper struct {
}

func NewEventMapper added in v1.2.21 

func NewEventMapper() *EventMapper

func (*EventMapper) FromProperties added in v1.2.21 

func (m *EventMapper) FromProperties(properties map[string]*structpb.Value) *Event

func (*EventMapper) New added in v1.2.21 

func (m *EventMapper) New() *Event

func (*EventMapper) ResourceIdentity added in v1.2.21 

func (m *EventMapper) ResourceIdentity() abs.ResourceIdentity

func (*EventMapper) ToProperties added in v1.2.21 

func (m *EventMapper) ToProperties(event *Event) map[string]*structpb.Value

func (*EventMapper) ToUnstructured added in v1.3.43 

func (m *EventMapper) ToUnstructured(event *Event) unstructured.Unstructured

type EventSelector added in v1.2.21 

type EventSelector struct {
	Actions        []EventAction      `json:"actions,omitempty"`
	RecordSelector *BooleanExpression `json:"recordSelector,omitempty"`
	Namespaces     []string           `json:"namespaces,omitempty"`
	Resources      []string           `json:"resources,omitempty"`
	Ids            []string           `json:"ids,omitempty"`
	Annotations    map[string]string  `json:"annotations,omitempty"`
}

func (EventSelector) GetActions added in v1.2.21 

func (s EventSelector) GetActions() []EventAction

func (EventSelector) GetAnnotations added in v1.2.21 

func (s EventSelector) GetAnnotations() map[string]string

func (EventSelector) GetIds added in v1.2.21 

func (s EventSelector) GetIds() []string

func (EventSelector) GetNamespaces added in v1.2.21 

func (s EventSelector) GetNamespaces() []string

func (EventSelector) GetRecordSelector added in v1.2.21 

func (s EventSelector) GetRecordSelector() *BooleanExpression

func (EventSelector) GetResources added in v1.2.21 

func (s EventSelector) GetResources() []string

type EventSelectorMapper added in v1.2.21 

type EventSelectorMapper struct {
}

func NewEventSelectorMapper added in v1.2.21 

func NewEventSelectorMapper() *EventSelectorMapper

func (*EventSelectorMapper) FromProperties added in v1.2.21 

func (m *EventSelectorMapper) FromProperties(properties map[string]*structpb.Value) *EventSelector

func (*EventSelectorMapper) New added in v1.2.21 

func (m *EventSelectorMapper) New() *EventSelector

func (*EventSelectorMapper) ResourceIdentity added in v1.2.21 

func (m *EventSelectorMapper) ResourceIdentity() abs.ResourceIdentity

func (*EventSelectorMapper) ToProperties added in v1.2.21 

func (m *EventSelectorMapper) ToProperties(eventSelector *EventSelector) map[string]*structpb.Value

func (*EventSelectorMapper) ToUnstructured added in v1.3.43 

func (m *EventSelectorMapper) ToUnstructured(eventSelector *EventSelector) unstructured.Unstructured

type Expression added in v1.2.39 

type Expression struct {
	Property *string     `json:"property,omitempty"`
	Value    interface{} `json:"value,omitempty"`
}

func (Expression) GetProperty added in v1.2.39 

func (s Expression) GetProperty() *string

func (Expression) GetValue added in v1.2.39 

func (s Expression) GetValue() interface{}

type ExpressionMapper added in v1.2.39 

type ExpressionMapper struct {
}

func NewExpressionMapper added in v1.2.39 

func NewExpressionMapper() *ExpressionMapper

func (*ExpressionMapper) FromProperties added in v1.2.39 

func (m *ExpressionMapper) FromProperties(properties map[string]*structpb.Value) *Expression

func (*ExpressionMapper) New added in v1.2.39 

func (m *ExpressionMapper) New() *Expression

func (*ExpressionMapper) ResourceIdentity added in v1.2.39 

func (m *ExpressionMapper) ResourceIdentity() abs.ResourceIdentity

func (*ExpressionMapper) ToProperties added in v1.2.39 

func (m *ExpressionMapper) ToProperties(expression *Expression) map[string]*structpb.Value

func (*ExpressionMapper) ToUnstructured added in v1.3.43 

func (m *ExpressionMapper) ToUnstructured(expression *Expression) unstructured.Unstructured

type Extension 

type Extension struct {
	Id          *uuid.UUID          `json:"id,omitempty"`
	Version     int32               `json:"version,omitempty"`
	AuditData   *ExtensionAuditData `json:"auditData,omitempty"`
	Name        string              `json:"name,omitempty"`
	Description *string             `json:"description,omitempty"`
	Selector    *EventSelector      `json:"selector,omitempty"`
	Order       int32               `json:"order,omitempty"`
	Finalizes   bool                `json:"finalizes,omitempty"`
	Sync        bool                `json:"sync,omitempty"`
	Responds    bool                `json:"responds,omitempty"`
	Call        ExternalCall        `json:"call,omitempty"`
	Annotations map[string]string   `json:"annotations,omitempty"`
}

func (Extension) GetAnnotations 

func (s Extension) GetAnnotations() map[string]string

func (Extension) GetAuditData added in v1.2.36 

func (s Extension) GetAuditData() *ExtensionAuditData

func (Extension) GetCall 

func (s Extension) GetCall() ExternalCall

func (Extension) GetDescription 

func (s Extension) GetDescription() *string

func (Extension) GetFinalizes 

func (s Extension) GetFinalizes() bool

func (Extension) GetId 

func (s Extension) GetId() *uuid.UUID

func (Extension) GetName 

func (s Extension) GetName() string

func (Extension) GetOrder 

func (s Extension) GetOrder() int32

func (Extension) GetResponds 

func (s Extension) GetResponds() bool

func (Extension) GetSelector 

func (s Extension) GetSelector() *EventSelector

func (Extension) GetSync 

func (s Extension) GetSync() bool

func (Extension) GetVersion 

func (s Extension) GetVersion() int32

type ExtensionAction added in v1.1.48 

type ExtensionAction string
const (
	ExtensionAction_CREATE  ExtensionAction = "CREATE"
	ExtensionAction_UPDATE  ExtensionAction = "UPDATE"
	ExtensionAction_DELETE  ExtensionAction = "DELETE"
	ExtensionAction_GET     ExtensionAction = "GET"
	ExtensionAction_LIST    ExtensionAction = "LIST"
	ExtensionAction_OPERATE ExtensionAction = "OPERATE"
)

type ExtensionAuditData added in v1.2.36 

type ExtensionAuditData struct {
	CreatedBy *string    `json:"createdBy,omitempty"`
	UpdatedBy *string    `json:"updatedBy,omitempty"`
	CreatedOn *time.Time `json:"createdOn,omitempty"`
	UpdatedOn *time.Time `json:"updatedOn,omitempty"`
}

func (ExtensionAuditData) GetCreatedBy added in v1.2.36 

func (s ExtensionAuditData) GetCreatedBy() *string

func (ExtensionAuditData) GetCreatedOn added in v1.2.36 

func (s ExtensionAuditData) GetCreatedOn() *time.Time

func (ExtensionAuditData) GetUpdatedBy added in v1.2.36 

func (s ExtensionAuditData) GetUpdatedBy() *string

func (ExtensionAuditData) GetUpdatedOn added in v1.2.36 

func (s ExtensionAuditData) GetUpdatedOn() *time.Time

type ExtensionAuditDataMapper added in v1.2.36 

type ExtensionAuditDataMapper struct {
}

func NewExtensionAuditDataMapper added in v1.2.36 

func NewExtensionAuditDataMapper() *ExtensionAuditDataMapper

func (*ExtensionAuditDataMapper) FromProperties added in v1.2.36 

func (m *ExtensionAuditDataMapper) FromProperties(properties map[string]*structpb.Value) *ExtensionAuditData

func (*ExtensionAuditDataMapper) New added in v1.2.36 

func (m *ExtensionAuditDataMapper) New() *ExtensionAuditData

func (*ExtensionAuditDataMapper) ResourceIdentity added in v1.2.36 

func (m *ExtensionAuditDataMapper) ResourceIdentity() abs.ResourceIdentity

func (*ExtensionAuditDataMapper) ToProperties added in v1.2.36 

func (m *ExtensionAuditDataMapper) ToProperties(extensionAuditData *ExtensionAuditData) map[string]*structpb.Value

func (*ExtensionAuditDataMapper) ToUnstructured added in v1.3.43 

func (m *ExtensionAuditDataMapper) ToUnstructured(extensionAuditData *ExtensionAuditData) unstructured.Unstructured

type ExtensionCode added in v1.1.48 

type ExtensionCode string
const (
	ExtensionCode_UNKNOWNERROR                      ExtensionCode = "UNKNOWN_ERROR"
	ExtensionCode_RECORDNOTFOUND                    ExtensionCode = "RECORD_NOT_FOUND"
	ExtensionCode_UNABLETOLOCATEPRIMARYKEY          ExtensionCode = "UNABLE_TO_LOCATE_PRIMARY_KEY"
	ExtensionCode_INTERNALERROR                     ExtensionCode = "INTERNAL_ERROR"
	ExtensionCode_PROPERTYNOTFOUND                  ExtensionCode = "PROPERTY_NOT_FOUND"
	ExtensionCode_RECORDVALIDATIONERROR             ExtensionCode = "RECORD_VALIDATION_ERROR"
	ExtensionCode_RESOURCEVALIDATIONERROR           ExtensionCode = "RESOURCE_VALIDATION_ERROR"
	ExtensionCode_AUTHENTICATIONFAILED              ExtensionCode = "AUTHENTICATION_FAILED"
	ExtensionCode_ALREADYEXISTS                     ExtensionCode = "ALREADY_EXISTS"
	ExtensionCode_ACCESSDENIED                      ExtensionCode = "ACCESS_DENIED"
	ExtensionCode_BACKENDERROR                      ExtensionCode = "BACKEND_ERROR"
	ExtensionCode_UNIQUEVIOLATION                   ExtensionCode = "UNIQUE_VIOLATION"
	ExtensionCode_REFERENCEVIOLATION                ExtensionCode = "REFERENCE_VIOLATION"
	ExtensionCode_RESOURCENOTFOUND                  ExtensionCode = "RESOURCE_NOT_FOUND"
	ExtensionCode_UNSUPPORTEDOPERATION              ExtensionCode = "UNSUPPORTED_OPERATION"
	ExtensionCode_EXTERNALBACKENDCOMMUNICATIONERROR ExtensionCode = "EXTERNAL_BACKEND_COMMUNICATION_ERROR"
	ExtensionCode_EXTERNALBACKENDERROR              ExtensionCode = "EXTERNAL_BACKEND_ERROR"
	ExtensionCode_RATELIMITERROR                    ExtensionCode = "RATE_LIMIT_ERROR"
)

type ExtensionMapper 

type ExtensionMapper struct {
}

func NewExtensionMapper 

func NewExtensionMapper() *ExtensionMapper

func (*ExtensionMapper) FromProperties 

func (m *ExtensionMapper) FromProperties(properties map[string]*structpb.Value) *Extension

func (*ExtensionMapper) FromRecord 

func (m *ExtensionMapper) FromRecord(record *model.Record) *Extension

func (*ExtensionMapper) New 

func (m *ExtensionMapper) New() *Extension

func (*ExtensionMapper) ResourceIdentity 

func (m *ExtensionMapper) ResourceIdentity() abs.ResourceIdentity

func (*ExtensionMapper) ToProperties 

func (m *ExtensionMapper) ToProperties(extension *Extension) map[string]*structpb.Value

func (*ExtensionMapper) ToRecord 

func (m *ExtensionMapper) ToRecord(extension *Extension) *model.Record

func (*ExtensionMapper) ToUnstructured added in v1.3.43 

func (m *ExtensionMapper) ToUnstructured(extension *Extension) unstructured.Unstructured

type ExternalCall added in v1.2.21 

type ExternalCall struct {
	FunctionCall *FunctionCall `json:"functionCall,omitempty"`
	HttpCall     *HttpCall     `json:"httpCall,omitempty"`
	ChannelCall  *ChannelCall  `json:"channelCall,omitempty"`
}

func (ExternalCall) GetChannelCall added in v1.2.21 

func (s ExternalCall) GetChannelCall() *ChannelCall

func (ExternalCall) GetFunctionCall added in v1.2.21 

func (s ExternalCall) GetFunctionCall() *FunctionCall

func (ExternalCall) GetHttpCall added in v1.2.21 

func (s ExternalCall) GetHttpCall() *HttpCall

type ExternalCallMapper added in v1.2.21 

type ExternalCallMapper struct {
}

func NewExternalCallMapper added in v1.2.21 

func NewExternalCallMapper() *ExternalCallMapper

func (*ExternalCallMapper) FromProperties added in v1.2.21 

func (m *ExternalCallMapper) FromProperties(properties map[string]*structpb.Value) *ExternalCall

func (*ExternalCallMapper) New added in v1.2.21 

func (m *ExternalCallMapper) New() *ExternalCall

func (*ExternalCallMapper) ResourceIdentity added in v1.2.21 

func (m *ExternalCallMapper) ResourceIdentity() abs.ResourceIdentity

func (*ExternalCallMapper) ToProperties added in v1.2.21 

func (m *ExternalCallMapper) ToProperties(externalCall *ExternalCall) map[string]*structpb.Value

func (*ExternalCallMapper) ToUnstructured added in v1.3.43 

func (m *ExternalCallMapper) ToUnstructured(externalCall *ExternalCall) unstructured.Unstructured

type FunctionCall added in v1.2.21 

type FunctionCall struct {
	Host         string `json:"host,omitempty"`
	FunctionName string `json:"functionName,omitempty"`
}

func (FunctionCall) GetFunctionName added in v1.2.21 

func (s FunctionCall) GetFunctionName() string

func (FunctionCall) GetHost added in v1.2.21 

func (s FunctionCall) GetHost() string

type FunctionCallMapper added in v1.2.21 

type FunctionCallMapper struct {
}

func NewFunctionCallMapper added in v1.2.21 

func NewFunctionCallMapper() *FunctionCallMapper

func (*FunctionCallMapper) FromProperties added in v1.2.21 

func (m *FunctionCallMapper) FromProperties(properties map[string]*structpb.Value) *FunctionCall

func (*FunctionCallMapper) New added in v1.2.21 

func (m *FunctionCallMapper) New() *FunctionCall

func (*FunctionCallMapper) ResourceIdentity added in v1.2.21 

func (m *FunctionCallMapper) ResourceIdentity() abs.ResourceIdentity

func (*FunctionCallMapper) ToProperties added in v1.2.21 

func (m *FunctionCallMapper) ToProperties(functionCall *FunctionCall) map[string]*structpb.Value

func (*FunctionCallMapper) ToUnstructured added in v1.3.43 

func (m *FunctionCallMapper) ToUnstructured(functionCall *FunctionCall) unstructured.Unstructured

type HttpCall added in v1.2.21 

type HttpCall struct {
	Uri    string `json:"uri,omitempty"`
	Method string `json:"method,omitempty"`
}

func (HttpCall) GetMethod added in v1.2.21 

func (s HttpCall) GetMethod() string

func (HttpCall) GetUri added in v1.2.21 

func (s HttpCall) GetUri() string

type HttpCallMapper added in v1.2.21 

type HttpCallMapper struct {
}

func NewHttpCallMapper added in v1.2.21 

func NewHttpCallMapper() *HttpCallMapper

func (*HttpCallMapper) FromProperties added in v1.2.21 

func (m *HttpCallMapper) FromProperties(properties map[string]*structpb.Value) *HttpCall

func (*HttpCallMapper) New added in v1.2.21 

func (m *HttpCallMapper) New() *HttpCall

func (*HttpCallMapper) ResourceIdentity added in v1.2.21 

func (m *HttpCallMapper) ResourceIdentity() abs.ResourceIdentity

func (*HttpCallMapper) ToProperties added in v1.2.21 

func (m *HttpCallMapper) ToProperties(httpCall *HttpCall) map[string]*structpb.Value

func (*HttpCallMapper) ToUnstructured added in v1.3.43 

func (m *HttpCallMapper) ToUnstructured(httpCall *HttpCall) unstructured.Unstructured

type Namespace 

type Namespace struct {
	Id          *uuid.UUID          `json:"id,omitempty"`
	Version     int32               `json:"version,omitempty"`
	AuditData   *NamespaceAuditData `json:"auditData,omitempty"`
	Name        string              `json:"name,omitempty"`
	Description *string             `json:"description,omitempty"`
	Details     interface{}         `json:"details,omitempty"`
}

func (Namespace) GetAuditData added in v1.2.36 

func (s Namespace) GetAuditData() *NamespaceAuditData

func (Namespace) GetDescription 

func (s Namespace) GetDescription() *string

func (Namespace) GetDetails 

func (s Namespace) GetDetails() interface{}

func (Namespace) GetId 

func (s Namespace) GetId() *uuid.UUID

func (Namespace) GetName 

func (s Namespace) GetName() string

func (Namespace) GetVersion 

func (s Namespace) GetVersion() int32

type NamespaceAuditData added in v1.2.36 

type NamespaceAuditData struct {
	CreatedBy *string    `json:"createdBy,omitempty"`
	UpdatedBy *string    `json:"updatedBy,omitempty"`
	CreatedOn *time.Time `json:"createdOn,omitempty"`
	UpdatedOn *time.Time `json:"updatedOn,omitempty"`
}

func (NamespaceAuditData) GetCreatedBy added in v1.2.36 

func (s NamespaceAuditData) GetCreatedBy() *string

func (NamespaceAuditData) GetCreatedOn added in v1.2.36 

func (s NamespaceAuditData) GetCreatedOn() *time.Time

func (NamespaceAuditData) GetUpdatedBy added in v1.2.36 

func (s NamespaceAuditData) GetUpdatedBy() *string

func (NamespaceAuditData) GetUpdatedOn added in v1.2.36 

func (s NamespaceAuditData) GetUpdatedOn() *time.Time

type NamespaceAuditDataMapper added in v1.2.36 

type NamespaceAuditDataMapper struct {
}

func NewNamespaceAuditDataMapper added in v1.2.36 

func NewNamespaceAuditDataMapper() *NamespaceAuditDataMapper

func (*NamespaceAuditDataMapper) FromProperties added in v1.2.36 

func (m *NamespaceAuditDataMapper) FromProperties(properties map[string]*structpb.Value) *NamespaceAuditData

func (*NamespaceAuditDataMapper) New added in v1.2.36 

func (m *NamespaceAuditDataMapper) New() *NamespaceAuditData

func (*NamespaceAuditDataMapper) ResourceIdentity added in v1.2.36 

func (m *NamespaceAuditDataMapper) ResourceIdentity() abs.ResourceIdentity

func (*NamespaceAuditDataMapper) ToProperties added in v1.2.36 

func (m *NamespaceAuditDataMapper) ToProperties(namespaceAuditData *NamespaceAuditData) map[string]*structpb.Value

func (*NamespaceAuditDataMapper) ToUnstructured added in v1.3.43 

func (m *NamespaceAuditDataMapper) ToUnstructured(namespaceAuditData *NamespaceAuditData) unstructured.Unstructured

type NamespaceMapper 

type NamespaceMapper struct {
}

func NewNamespaceMapper 

func NewNamespaceMapper() *NamespaceMapper

func (*NamespaceMapper) FromProperties 

func (m *NamespaceMapper) FromProperties(properties map[string]*structpb.Value) *Namespace

func (*NamespaceMapper) FromRecord 

func (m *NamespaceMapper) FromRecord(record *model.Record) *Namespace

func (*NamespaceMapper) New 

func (m *NamespaceMapper) New() *Namespace

func (*NamespaceMapper) ResourceIdentity 

func (m *NamespaceMapper) ResourceIdentity() abs.ResourceIdentity

func (*NamespaceMapper) ToProperties 

func (m *NamespaceMapper) ToProperties(namespace *Namespace) map[string]*structpb.Value

func (*NamespaceMapper) ToRecord 

func (m *NamespaceMapper) ToRecord(namespace *Namespace) *model.Record

func (*NamespaceMapper) ToUnstructured added in v1.3.43 

func (m *NamespaceMapper) ToUnstructured(namespace *Namespace) unstructured.Unstructured

type PairExpression added in v1.2.39 

type PairExpression struct {
	Left  *Expression `json:"left,omitempty"`
	Right *Expression `json:"right,omitempty"`
}

func (PairExpression) GetLeft added in v1.2.39 

func (s PairExpression) GetLeft() *Expression

func (PairExpression) GetRight added in v1.2.39 

func (s PairExpression) GetRight() *Expression

type PairExpressionMapper added in v1.2.39 

type PairExpressionMapper struct {
}

func NewPairExpressionMapper added in v1.2.39 

func NewPairExpressionMapper() *PairExpressionMapper

func (*PairExpressionMapper) FromProperties added in v1.2.39 

func (m *PairExpressionMapper) FromProperties(properties map[string]*structpb.Value) *PairExpression

func (*PairExpressionMapper) New added in v1.2.39 

func (m *PairExpressionMapper) New() *PairExpression

func (*PairExpressionMapper) ResourceIdentity added in v1.2.39 

func (m *PairExpressionMapper) ResourceIdentity() abs.ResourceIdentity

func (*PairExpressionMapper) ToProperties added in v1.2.39 

func (m *PairExpressionMapper) ToProperties(pairExpression *PairExpression) map[string]*structpb.Value

func (*PairExpressionMapper) ToUnstructured added in v1.3.43 

func (m *PairExpressionMapper) ToUnstructured(pairExpression *PairExpression) unstructured.Unstructured

type Permission added in v1.1.40 

type Permission struct {
	Id             *uuid.UUID           `json:"id,omitempty"`
	Version        int32                `json:"version,omitempty"`
	AuditData      *PermissionAuditData `json:"auditData,omitempty"`
	Namespace      *string              `json:"namespace,omitempty"`
	Resource       *string              `json:"resource,omitempty"`
	RecordSelector *BooleanExpression   `json:"recordSelector,omitempty"`
	Operation      PermissionOperation  `json:"operation,omitempty"`
	Before         *time.Time           `json:"before,omitempty"`
	After          *time.Time           `json:"after,omitempty"`
	User           *User                `json:"user,omitempty"`
	Role           *Role                `json:"role,omitempty"`
	Permit         PermissionPermit     `json:"permit,omitempty"`
	LocalFlags     interface{}          `json:"localFlags,omitempty"`
}

func (Permission) GetAfter added in v1.1.40 

func (s Permission) GetAfter() *time.Time

func (Permission) GetAuditData added in v1.2.36 

func (s Permission) GetAuditData() *PermissionAuditData

func (Permission) GetBefore added in v1.1.40 

func (s Permission) GetBefore() *time.Time

func (Permission) GetId added in v1.1.40 

func (s Permission) GetId() *uuid.UUID

func (Permission) GetLocalFlags added in v1.1.40 

func (s Permission) GetLocalFlags() interface{}

func (Permission) GetNamespace added in v1.1.40 

func (s Permission) GetNamespace() *string

func (Permission) GetOperation added in v1.1.40 

func (s Permission) GetOperation() PermissionOperation

func (Permission) GetPermit added in v1.1.40 

func (s Permission) GetPermit() PermissionPermit

func (Permission) GetRecordSelector added in v1.2.39 

func (s Permission) GetRecordSelector() *BooleanExpression

func (Permission) GetResource added in v1.1.40 

func (s Permission) GetResource() *string

func (Permission) GetRole added in v1.1.40 

func (s Permission) GetRole() *Role

func (Permission) GetUser added in v1.1.40 

func (s Permission) GetUser() *User

func (Permission) GetVersion added in v1.1.40 

func (s Permission) GetVersion() int32

type PermissionAuditData added in v1.2.36 

type PermissionAuditData struct {
	CreatedBy *string    `json:"createdBy,omitempty"`
	UpdatedBy *string    `json:"updatedBy,omitempty"`
	CreatedOn *time.Time `json:"createdOn,omitempty"`
	UpdatedOn *time.Time `json:"updatedOn,omitempty"`
}

func (PermissionAuditData) GetCreatedBy added in v1.2.36 

func (s PermissionAuditData) GetCreatedBy() *string

func (PermissionAuditData) GetCreatedOn added in v1.2.36 

func (s PermissionAuditData) GetCreatedOn() *time.Time

func (PermissionAuditData) GetUpdatedBy added in v1.2.36 

func (s PermissionAuditData) GetUpdatedBy() *string

func (PermissionAuditData) GetUpdatedOn added in v1.2.36 

func (s PermissionAuditData) GetUpdatedOn() *time.Time

type PermissionAuditDataMapper added in v1.2.36 

type PermissionAuditDataMapper struct {
}

func NewPermissionAuditDataMapper added in v1.2.36 

func NewPermissionAuditDataMapper() *PermissionAuditDataMapper

func (*PermissionAuditDataMapper) FromProperties added in v1.2.36 

func (m *PermissionAuditDataMapper) FromProperties(properties map[string]*structpb.Value) *PermissionAuditData

func (*PermissionAuditDataMapper) New added in v1.2.36 

func (m *PermissionAuditDataMapper) New() *PermissionAuditData

func (*PermissionAuditDataMapper) ResourceIdentity added in v1.2.36 

func (m *PermissionAuditDataMapper) ResourceIdentity() abs.ResourceIdentity

func (*PermissionAuditDataMapper) ToProperties added in v1.2.36 

func (m *PermissionAuditDataMapper) ToProperties(permissionAuditData *PermissionAuditData) map[string]*structpb.Value

func (*PermissionAuditDataMapper) ToUnstructured added in v1.3.43 

func (m *PermissionAuditDataMapper) ToUnstructured(permissionAuditData *PermissionAuditData) unstructured.Unstructured

type PermissionMapper added in v1.1.44 

type PermissionMapper struct {
}

func NewPermissionMapper added in v1.1.44 

func NewPermissionMapper() *PermissionMapper

func (*PermissionMapper) FromProperties added in v1.1.44 

func (m *PermissionMapper) FromProperties(properties map[string]*structpb.Value) *Permission

func (*PermissionMapper) FromRecord added in v1.1.44 

func (m *PermissionMapper) FromRecord(record *model.Record) *Permission

func (*PermissionMapper) New added in v1.1.44 

func (m *PermissionMapper) New() *Permission

func (*PermissionMapper) ResourceIdentity added in v1.1.44 

func (m *PermissionMapper) ResourceIdentity() abs.ResourceIdentity

func (*PermissionMapper) ToProperties added in v1.1.44 

func (m *PermissionMapper) ToProperties(permission *Permission) map[string]*structpb.Value

func (*PermissionMapper) ToRecord added in v1.1.44 

func (m *PermissionMapper) ToRecord(permission *Permission) *model.Record

func (*PermissionMapper) ToUnstructured added in v1.3.43 

func (m *PermissionMapper) ToUnstructured(permission *Permission) unstructured.Unstructured

type PermissionOperation added in v1.1.44 

type PermissionOperation string
const (
	PermissionOperation_READ   PermissionOperation = "READ"
	PermissionOperation_CREATE PermissionOperation = "CREATE"
	PermissionOperation_UPDATE PermissionOperation = "UPDATE"
	PermissionOperation_DELETE PermissionOperation = "DELETE"
	PermissionOperation_FULL   PermissionOperation = "FULL"
)

type PermissionPermit added in v1.1.44 

type PermissionPermit string
const (
	PermissionPermit_ALLOW  PermissionPermit = "ALLOW"
	PermissionPermit_REJECT PermissionPermit = "REJECT"
)

type Property added in v1.2.21 

type Property struct {
	Type          ResourceType      `json:"type,omitempty"`
	TypeRef       *string           `json:"typeRef,omitempty"`
	Primary       bool              `json:"primary,omitempty"`
	Required      bool              `json:"required,omitempty"`
	Unique        bool              `json:"unique,omitempty"`
	Immutable     bool              `json:"immutable,omitempty"`
	Virtual       bool              `json:"virtual,omitempty"`
	Length        int32             `json:"length,omitempty"`
	Item          *Property         `json:"item,omitempty"`
	Reference     *string           `json:"reference,omitempty"`
	BackReference *string           `json:"backReference,omitempty"`
	DefaultValue  interface{}       `json:"defaultValue,omitempty"`
	EnumValues    []string          `json:"enumValues,omitempty"`
	ExampleValue  interface{}       `json:"exampleValue,omitempty"`
	Title         *string           `json:"title,omitempty"`
	Description   *string           `json:"description,omitempty"`
	Annotations   map[string]string `json:"annotations,omitempty"`
}

func (Property) GetAnnotations added in v1.2.21 

func (s Property) GetAnnotations() map[string]string

func (Property) GetBackReference added in v1.2.85 

func (s Property) GetBackReference() *string

func (Property) GetDefaultValue added in v1.2.21 

func (s Property) GetDefaultValue() interface{}

func (Property) GetDescription added in v1.2.21 

func (s Property) GetDescription() *string

func (Property) GetEnumValues added in v1.2.21 

func (s Property) GetEnumValues() []string

func (Property) GetExampleValue added in v1.2.21 

func (s Property) GetExampleValue() interface{}

func (Property) GetImmutable added in v1.2.21 

func (s Property) GetImmutable() bool

func (Property) GetItem added in v1.2.21 

func (s Property) GetItem() *Property

func (Property) GetLength added in v1.2.21 

func (s Property) GetLength() int32

func (Property) GetPrimary added in v1.2.21 

func (s Property) GetPrimary() bool

func (Property) GetReference added in v1.2.21 

func (s Property) GetReference() *string

func (Property) GetRequired added in v1.2.21 

func (s Property) GetRequired() bool

func (Property) GetTitle added in v1.2.21 

func (s Property) GetTitle() *string

func (Property) GetType added in v1.2.21 

func (s Property) GetType() ResourceType

func (Property) GetTypeRef added in v1.2.21 

func (s Property) GetTypeRef() *string

func (Property) GetUnique added in v1.2.21 

func (s Property) GetUnique() bool

func (Property) GetVirtual added in v1.3.43 

func (s Property) GetVirtual() bool

type PropertyMapper added in v1.2.21 

type PropertyMapper struct {
}

func NewPropertyMapper added in v1.2.21 

func NewPropertyMapper() *PropertyMapper

func (*PropertyMapper) FromProperties added in v1.2.21 

func (m *PropertyMapper) FromProperties(properties map[string]*structpb.Value) *Property

func (*PropertyMapper) New added in v1.2.21 

func (m *PropertyMapper) New() *Property

func (*PropertyMapper) ResourceIdentity added in v1.2.21 

func (m *PropertyMapper) ResourceIdentity() abs.ResourceIdentity

func (*PropertyMapper) ToProperties added in v1.2.21 

func (m *PropertyMapper) ToProperties(property *Property) map[string]*structpb.Value

func (*PropertyMapper) ToUnstructured added in v1.3.43 

func (m *PropertyMapper) ToUnstructured(property *Property) unstructured.Unstructured

type Record 

type Record struct {
	Id               *uuid.UUID    `json:"id,omitempty"`
	Properties       interface{}   `json:"properties,omitempty"`
	PackedProperties []interface{} `json:"packedProperties,omitempty"`
}

func (Record) GetId 

func (s Record) GetId() *uuid.UUID

func (Record) GetPackedProperties 

func (s Record) GetPackedProperties() []interface{}

func (Record) GetProperties 

func (s Record) GetProperties() interface{}

type RecordMapper 

type RecordMapper struct {
}

func NewRecordMapper 

func NewRecordMapper() *RecordMapper

func (*RecordMapper) FromProperties 

func (m *RecordMapper) FromProperties(properties map[string]*structpb.Value) *Record

func (*RecordMapper) FromRecord 

func (m *RecordMapper) FromRecord(record *model.Record) *Record

func (*RecordMapper) New 

func (m *RecordMapper) New() *Record

func (*RecordMapper) ResourceIdentity 

func (m *RecordMapper) ResourceIdentity() abs.ResourceIdentity

func (*RecordMapper) ToProperties 

func (m *RecordMapper) ToProperties(record *Record) map[string]*structpb.Value

func (*RecordMapper) ToRecord 

func (m *RecordMapper) ToRecord(record *Record) *model.Record

func (*RecordMapper) ToUnstructured added in v1.3.43 

func (m *RecordMapper) ToUnstructured(record *Record) unstructured.Unstructured

type RecordSearchParams added in v1.2.21 

type RecordSearchParams struct {
	Query             *BooleanExpression `json:"query,omitempty"`
	Limit             *int32             `json:"limit,omitempty"`
	Offset            *int32             `json:"offset,omitempty"`
	ResolveReferences []string           `json:"resolveReferences,omitempty"`
}

func (RecordSearchParams) GetLimit added in v1.2.21 

func (s RecordSearchParams) GetLimit() *int32

func (RecordSearchParams) GetOffset added in v1.2.21 

func (s RecordSearchParams) GetOffset() *int32

func (RecordSearchParams) GetQuery added in v1.2.21 

func (s RecordSearchParams) GetQuery() *BooleanExpression

func (RecordSearchParams) GetResolveReferences added in v1.2.21 

func (s RecordSearchParams) GetResolveReferences() []string

type RecordSearchParamsMapper added in v1.2.21 

type RecordSearchParamsMapper struct {
}

func NewRecordSearchParamsMapper added in v1.2.21 

func NewRecordSearchParamsMapper() *RecordSearchParamsMapper

func (*RecordSearchParamsMapper) FromProperties added in v1.2.21 

func (m *RecordSearchParamsMapper) FromProperties(properties map[string]*structpb.Value) *RecordSearchParams

func (*RecordSearchParamsMapper) New added in v1.2.21 

func (m *RecordSearchParamsMapper) New() *RecordSearchParams

func (*RecordSearchParamsMapper) ResourceIdentity added in v1.2.21 

func (m *RecordSearchParamsMapper) ResourceIdentity() abs.ResourceIdentity

func (*RecordSearchParamsMapper) ToProperties added in v1.2.21 

func (m *RecordSearchParamsMapper) ToProperties(recordSearchParams *RecordSearchParams) map[string]*structpb.Value

func (*RecordSearchParamsMapper) ToUnstructured added in v1.3.43 

func (m *RecordSearchParamsMapper) ToUnstructured(recordSearchParams *RecordSearchParams) unstructured.Unstructured

type Resource 

type Resource struct {
	Id              *uuid.UUID          `json:"id,omitempty"`
	Version         int32               `json:"version,omitempty"`
	AuditData       *ResourceAuditData  `json:"auditData,omitempty"`
	Name            string              `json:"name,omitempty"`
	Namespace       *Namespace          `json:"namespace,omitempty"`
	Virtual         bool                `json:"virtual,omitempty"`
	Properties      map[string]Property `json:"properties,omitempty"`
	Indexes         []ResourceIndex     `json:"indexes,omitempty"`
	Types           []SubType           `json:"types,omitempty"`
	Immutable       bool                `json:"immutable,omitempty"`
	Abstract        bool                `json:"abstract,omitempty"`
	CheckReferences bool                `json:"checkReferences,omitempty"`
	DataSource      *DataSource         `json:"dataSource,omitempty"`
	Entity          *string             `json:"entity,omitempty"`
	Catalog         *string             `json:"catalog,omitempty"`
	Title           *string             `json:"title,omitempty"`
	Description     *string             `json:"description,omitempty"`
	Annotations     map[string]string   `json:"annotations,omitempty"`
}

func (Resource) GetAbstract 

func (s Resource) GetAbstract() bool

func (Resource) GetAnnotations 

func (s Resource) GetAnnotations() map[string]string

func (Resource) GetAuditData added in v1.2.36 

func (s Resource) GetAuditData() *ResourceAuditData

func (Resource) GetCatalog 

func (s Resource) GetCatalog() *string

func (Resource) GetCheckReferences 

func (s Resource) GetCheckReferences() bool

func (Resource) GetDataSource 

func (s Resource) GetDataSource() *DataSource

func (Resource) GetDescription 

func (s Resource) GetDescription() *string

func (Resource) GetEntity 

func (s Resource) GetEntity() *string

func (Resource) GetId 

func (s Resource) GetId() *uuid.UUID

func (Resource) GetImmutable 

func (s Resource) GetImmutable() bool

func (Resource) GetIndexes 

func (s Resource) GetIndexes() []ResourceIndex

func (Resource) GetName 

func (s Resource) GetName() string

func (Resource) GetNamespace 

func (s Resource) GetNamespace() *Namespace

func (Resource) GetProperties 

func (s Resource) GetProperties() map[string]Property

func (Resource) GetTitle 

func (s Resource) GetTitle() *string

func (Resource) GetTypes 

func (s Resource) GetTypes() []SubType

func (Resource) GetVersion 

func (s Resource) GetVersion() int32

func (Resource) GetVirtual 

func (s Resource) GetVirtual() bool

type ResourceAction added in v1.2.21 

type ResourceAction struct {
	Id          *uuid.UUID               `json:"id,omitempty"`
	Version     int32                    `json:"version,omitempty"`
	AuditData   *ResourceActionAuditData `json:"auditData,omitempty"`
	Resource    *Resource                `json:"resource,omitempty"`
	Name        string                   `json:"name,omitempty"`
	Title       *string                  `json:"title,omitempty"`
	Description *string                  `json:"description,omitempty"`
	Internal    bool                     `json:"internal,omitempty"`
	Types       []SubType                `json:"types,omitempty"`
	Input       map[string]Property      `json:"input,omitempty"`
	Output      *Property                `json:"output,omitempty"`
	Annotations map[string]string        `json:"annotations,omitempty"`
}

func (ResourceAction) GetAnnotations added in v1.2.21 

func (s ResourceAction) GetAnnotations() map[string]string

func (*ResourceAction) GetAuditData added in v1.2.36 

func (s *ResourceAction) GetAuditData() *ResourceActionAuditData

func (*ResourceAction) GetDescription added in v1.2.21 

func (s *ResourceAction) GetDescription() *string

func (*ResourceAction) GetId added in v1.2.21 

func (s *ResourceAction) GetId() *uuid.UUID

func (*ResourceAction) GetInput added in v1.2.21 

func (s *ResourceAction) GetInput() map[string]Property

func (*ResourceAction) GetInternal added in v1.2.21 

func (s *ResourceAction) GetInternal() bool

func (*ResourceAction) GetName added in v1.2.21 

func (s *ResourceAction) GetName() string

func (*ResourceAction) GetOutput added in v1.2.21 

func (s *ResourceAction) GetOutput() *Property

func (*ResourceAction) GetResource added in v1.2.21 

func (s *ResourceAction) GetResource() *Resource

func (*ResourceAction) GetTitle added in v1.2.21 

func (s *ResourceAction) GetTitle() *string

func (*ResourceAction) GetTypes added in v1.2.21 

func (s *ResourceAction) GetTypes() []SubType

func (*ResourceAction) GetVersion added in v1.2.21 

func (s *ResourceAction) GetVersion() int32

type ResourceActionAuditData added in v1.2.36 

type ResourceActionAuditData struct {
	CreatedBy *string    `json:"createdBy,omitempty"`
	UpdatedBy *string    `json:"updatedBy,omitempty"`
	CreatedOn *time.Time `json:"createdOn,omitempty"`
	UpdatedOn *time.Time `json:"updatedOn,omitempty"`
}

func (*ResourceActionAuditData) GetCreatedBy added in v1.2.36 

func (s *ResourceActionAuditData) GetCreatedBy() *string

func (*ResourceActionAuditData) GetCreatedOn added in v1.2.36 

func (s *ResourceActionAuditData) GetCreatedOn() *time.Time

func (*ResourceActionAuditData) GetUpdatedBy added in v1.2.36 

func (s *ResourceActionAuditData) GetUpdatedBy() *string

func (*ResourceActionAuditData) GetUpdatedOn added in v1.2.36 

func (s *ResourceActionAuditData) GetUpdatedOn() *time.Time

type ResourceActionAuditDataMapper added in v1.2.36 

type ResourceActionAuditDataMapper struct {
}

func NewResourceActionAuditDataMapper added in v1.2.36 

func NewResourceActionAuditDataMapper() *ResourceActionAuditDataMapper

func (*ResourceActionAuditDataMapper) FromProperties added in v1.2.36 

func (m *ResourceActionAuditDataMapper) FromProperties(properties map[string]*structpb.Value) *ResourceActionAuditData

func (*ResourceActionAuditDataMapper) New added in v1.2.36 

func (m *ResourceActionAuditDataMapper) New() *ResourceActionAuditData

func (*ResourceActionAuditDataMapper) ResourceIdentity added in v1.2.36 

func (m *ResourceActionAuditDataMapper) ResourceIdentity() abs.ResourceIdentity

func (*ResourceActionAuditDataMapper) ToProperties added in v1.2.36 

func (m *ResourceActionAuditDataMapper) ToProperties(resourceActionAuditData *ResourceActionAuditData) map[string]*structpb.Value

func (*ResourceActionAuditDataMapper) ToUnstructured added in v1.3.43 

func (m *ResourceActionAuditDataMapper) ToUnstructured(resourceActionAuditData *ResourceActionAuditData) unstructured.Unstructured

type ResourceActionMapper added in v1.2.21 

type ResourceActionMapper struct {
}

func NewResourceActionMapper added in v1.2.21 

func NewResourceActionMapper() *ResourceActionMapper

func (*ResourceActionMapper) FromProperties added in v1.2.21 

func (m *ResourceActionMapper) FromProperties(properties map[string]*structpb.Value) *ResourceAction

func (*ResourceActionMapper) FromRecord added in v1.2.21 

func (m *ResourceActionMapper) FromRecord(record *model.Record) *ResourceAction

func (*ResourceActionMapper) New added in v1.2.21 

func (m *ResourceActionMapper) New() *ResourceAction

func (*ResourceActionMapper) ResourceIdentity added in v1.2.21 

func (m *ResourceActionMapper) ResourceIdentity() abs.ResourceIdentity

func (*ResourceActionMapper) ToProperties added in v1.2.21 

func (m *ResourceActionMapper) ToProperties(resourceAction *ResourceAction) map[string]*structpb.Value

func (*ResourceActionMapper) ToRecord added in v1.2.21 

func (m *ResourceActionMapper) ToRecord(resourceAction *ResourceAction) *model.Record

func (*ResourceActionMapper) ToUnstructured added in v1.3.43 

func (m *ResourceActionMapper) ToUnstructured(resourceAction *ResourceAction) unstructured.Unstructured

type ResourceActionType added in v1.2.21 

type ResourceActionType string
const (
	ResourceActionType_BOOL      ResourceActionType = "BOOL"
	ResourceActionType_STRING    ResourceActionType = "STRING"
	ResourceActionType_FLOAT32   ResourceActionType = "FLOAT32"
	ResourceActionType_FLOAT64   ResourceActionType = "FLOAT64"
	ResourceActionType_INT32     ResourceActionType = "INT32"
	ResourceActionType_INT64     ResourceActionType = "INT64"
	ResourceActionType_BYTES     ResourceActionType = "BYTES"
	ResourceActionType_UUID      ResourceActionType = "UUID"
	ResourceActionType_DATE      ResourceActionType = "DATE"
	ResourceActionType_TIME      ResourceActionType = "TIME"
	ResourceActionType_TIMESTAMP ResourceActionType = "TIMESTAMP"
	ResourceActionType_OBJECT    ResourceActionType = "OBJECT"
	ResourceActionType_MAP       ResourceActionType = "MAP"
	ResourceActionType_LIST      ResourceActionType = "LIST"
	ResourceActionType_REFERENCE ResourceActionType = "REFERENCE"
	ResourceActionType_ENUM      ResourceActionType = "ENUM"
	ResourceActionType_STRUCT    ResourceActionType = "STRUCT"
)

type ResourceAuditData added in v1.2.36 

type ResourceAuditData struct {
	CreatedBy *string    `json:"createdBy,omitempty"`
	UpdatedBy *string    `json:"updatedBy,omitempty"`
	CreatedOn *time.Time `json:"createdOn,omitempty"`
	UpdatedOn *time.Time `json:"updatedOn,omitempty"`
}

func (ResourceAuditData) GetCreatedBy added in v1.2.36 

func (s ResourceAuditData) GetCreatedBy() *string

func (ResourceAuditData) GetCreatedOn added in v1.2.36 

func (s ResourceAuditData) GetCreatedOn() *time.Time

func (ResourceAuditData) GetUpdatedBy added in v1.2.36 

func (s ResourceAuditData) GetUpdatedBy() *string

func (ResourceAuditData) GetUpdatedOn added in v1.2.36 

func (s ResourceAuditData) GetUpdatedOn() *time.Time

type ResourceAuditDataMapper added in v1.2.36 

type ResourceAuditDataMapper struct {
}

func NewResourceAuditDataMapper added in v1.2.36 

func NewResourceAuditDataMapper() *ResourceAuditDataMapper

func (*ResourceAuditDataMapper) FromProperties added in v1.2.36 

func (m *ResourceAuditDataMapper) FromProperties(properties map[string]*structpb.Value) *ResourceAuditData

func (*ResourceAuditDataMapper) New added in v1.2.36 

func (m *ResourceAuditDataMapper) New() *ResourceAuditData

func (*ResourceAuditDataMapper) ResourceIdentity added in v1.2.36 

func (m *ResourceAuditDataMapper) ResourceIdentity() abs.ResourceIdentity

func (*ResourceAuditDataMapper) ToProperties added in v1.2.36 

func (m *ResourceAuditDataMapper) ToProperties(resourceAuditData *ResourceAuditData) map[string]*structpb.Value

func (*ResourceAuditDataMapper) ToUnstructured added in v1.3.43 

func (m *ResourceAuditDataMapper) ToUnstructured(resourceAuditData *ResourceAuditData) unstructured.Unstructured

type ResourceIndex 

type ResourceIndex struct {
	Properties  []ResourceIndexProperty `json:"properties,omitempty"`
	IndexType   *ResourceIndexType      `json:"indexType,omitempty"`
	Unique      *bool                   `json:"unique,omitempty"`
	Annotations map[string]string       `json:"annotations,omitempty"`
}

func (ResourceIndex) GetAnnotations 

func (s ResourceIndex) GetAnnotations() map[string]string

func (ResourceIndex) GetIndexType 

func (s ResourceIndex) GetIndexType() *ResourceIndexType

func (ResourceIndex) GetProperties 

func (s ResourceIndex) GetProperties() []ResourceIndexProperty

func (ResourceIndex) GetUnique 

func (s ResourceIndex) GetUnique() *bool

type ResourceIndexMapper 

type ResourceIndexMapper struct {
}

func NewResourceIndexMapper 

func NewResourceIndexMapper() *ResourceIndexMapper

func (*ResourceIndexMapper) FromProperties 

func (m *ResourceIndexMapper) FromProperties(properties map[string]*structpb.Value) *ResourceIndex

func (*ResourceIndexMapper) New 

func (m *ResourceIndexMapper) New() *ResourceIndex

func (*ResourceIndexMapper) ResourceIdentity 

func (m *ResourceIndexMapper) ResourceIdentity() abs.ResourceIdentity

func (*ResourceIndexMapper) ToProperties 

func (m *ResourceIndexMapper) ToProperties(resourceIndex *ResourceIndex) map[string]*structpb.Value

func (*ResourceIndexMapper) ToUnstructured added in v1.3.43 

func (m *ResourceIndexMapper) ToUnstructured(resourceIndex *ResourceIndex) unstructured.Unstructured

type ResourceIndexProperty 

type ResourceIndexProperty struct {
	Name  string         `json:"name,omitempty"`
	Order *ResourceOrder `json:"order,omitempty"`
}

func (ResourceIndexProperty) GetName 

func (s ResourceIndexProperty) GetName() string

func (ResourceIndexProperty) GetOrder 

func (s ResourceIndexProperty) GetOrder() *ResourceOrder

type ResourceIndexPropertyMapper 

type ResourceIndexPropertyMapper struct {
}

func NewResourceIndexPropertyMapper 

func NewResourceIndexPropertyMapper() *ResourceIndexPropertyMapper

func (*ResourceIndexPropertyMapper) FromProperties 

func (m *ResourceIndexPropertyMapper) FromProperties(properties map[string]*structpb.Value) *ResourceIndexProperty

func (*ResourceIndexPropertyMapper) New 

func (m *ResourceIndexPropertyMapper) New() *ResourceIndexProperty

func (*ResourceIndexPropertyMapper) ResourceIdentity 

func (m *ResourceIndexPropertyMapper) ResourceIdentity() abs.ResourceIdentity

func (*ResourceIndexPropertyMapper) ToProperties 

func (m *ResourceIndexPropertyMapper) ToProperties(resourceIndexProperty *ResourceIndexProperty) map[string]*structpb.Value

func (*ResourceIndexPropertyMapper) ToUnstructured added in v1.3.43 

func (m *ResourceIndexPropertyMapper) ToUnstructured(resourceIndexProperty *ResourceIndexProperty) unstructured.Unstructured

type ResourceIndexType 

type ResourceIndexType string
const (
	ResourceIndexType_BTREE ResourceIndexType = "BTREE"
	ResourceIndexType_HASH  ResourceIndexType = "HASH"
)

type ResourceMapper 

type ResourceMapper struct {
}

func NewResourceMapper 

func NewResourceMapper() *ResourceMapper

func (*ResourceMapper) FromProperties 

func (m *ResourceMapper) FromProperties(properties map[string]*structpb.Value) *Resource

func (*ResourceMapper) FromRecord 

func (m *ResourceMapper) FromRecord(record *model.Record) *Resource

func (*ResourceMapper) New 

func (m *ResourceMapper) New() *Resource

func (*ResourceMapper) ResourceIdentity 

func (m *ResourceMapper) ResourceIdentity() abs.ResourceIdentity

func (*ResourceMapper) ToProperties 

func (m *ResourceMapper) ToProperties(resource *Resource) map[string]*structpb.Value

func (*ResourceMapper) ToRecord 

func (m *ResourceMapper) ToRecord(resource *Resource) *model.Record

func (*ResourceMapper) ToUnstructured added in v1.3.43 

func (m *ResourceMapper) ToUnstructured(resource *Resource) unstructured.Unstructured

type ResourceOrder 

type ResourceOrder string
const (
	ResourceOrder_UNKNOWN ResourceOrder = "UNKNOWN"
	ResourceOrder_ASC     ResourceOrder = "ASC"
	ResourceOrder_DESC    ResourceOrder = "DESC"
)

type ResourceType 

type ResourceType string
const (
	ResourceType_BOOL      ResourceType = "BOOL"
	ResourceType_STRING    ResourceType = "STRING"
	ResourceType_FLOAT32   ResourceType = "FLOAT32"
	ResourceType_FLOAT64   ResourceType = "FLOAT64"
	ResourceType_INT32     ResourceType = "INT32"
	ResourceType_INT64     ResourceType = "INT64"
	ResourceType_BYTES     ResourceType = "BYTES"
	ResourceType_UUID      ResourceType = "UUID"
	ResourceType_DATE      ResourceType = "DATE"
	ResourceType_TIME      ResourceType = "TIME"
	ResourceType_TIMESTAMP ResourceType = "TIMESTAMP"
	ResourceType_OBJECT    ResourceType = "OBJECT"
	ResourceType_MAP       ResourceType = "MAP"
	ResourceType_LIST      ResourceType = "LIST"
	ResourceType_REFERENCE ResourceType = "REFERENCE"
	ResourceType_ENUM      ResourceType = "ENUM"
	ResourceType_STRUCT    ResourceType = "STRUCT"
)

type Role 

type Role struct {
	Id          *uuid.UUID     `json:"id,omitempty"`
	Version     int32          `json:"version,omitempty"`
	AuditData   *RoleAuditData `json:"auditData,omitempty"`
	Name        string         `json:"name,omitempty"`
	Permissions []*Permission  `json:"permissions,omitempty"`
	Details     interface{}    `json:"details,omitempty"`
}

func (Role) GetAuditData added in v1.2.36 

func (s Role) GetAuditData() *RoleAuditData

func (Role) GetDetails 

func (s Role) GetDetails() interface{}

func (Role) GetId 

func (s Role) GetId() *uuid.UUID

func (Role) GetName 

func (s Role) GetName() string

func (Role) GetPermissions added in v1.1.44 

func (s Role) GetPermissions() []*Permission

func (Role) GetVersion 

func (s Role) GetVersion() int32

type RoleAuditData added in v1.2.36 

type RoleAuditData struct {
	CreatedBy *string    `json:"createdBy,omitempty"`
	UpdatedBy *string    `json:"updatedBy,omitempty"`
	CreatedOn *time.Time `json:"createdOn,omitempty"`
	UpdatedOn *time.Time `json:"updatedOn,omitempty"`
}

func (RoleAuditData) GetCreatedBy added in v1.2.36 

func (s RoleAuditData) GetCreatedBy() *string

func (RoleAuditData) GetCreatedOn added in v1.2.36 

func (s RoleAuditData) GetCreatedOn() *time.Time

func (RoleAuditData) GetUpdatedBy added in v1.2.36 

func (s RoleAuditData) GetUpdatedBy() *string

func (RoleAuditData) GetUpdatedOn added in v1.2.36 

func (s RoleAuditData) GetUpdatedOn() *time.Time

type RoleAuditDataMapper added in v1.2.36 

type RoleAuditDataMapper struct {
}

func NewRoleAuditDataMapper added in v1.2.36 

func NewRoleAuditDataMapper() *RoleAuditDataMapper

func (*RoleAuditDataMapper) FromProperties added in v1.2.36 

func (m *RoleAuditDataMapper) FromProperties(properties map[string]*structpb.Value) *RoleAuditData

func (*RoleAuditDataMapper) New added in v1.2.36 

func (m *RoleAuditDataMapper) New() *RoleAuditData

func (*RoleAuditDataMapper) ResourceIdentity added in v1.2.36 

func (m *RoleAuditDataMapper) ResourceIdentity() abs.ResourceIdentity

func (*RoleAuditDataMapper) ToProperties added in v1.2.36 

func (m *RoleAuditDataMapper) ToProperties(roleAuditData *RoleAuditData) map[string]*structpb.Value

func (*RoleAuditDataMapper) ToUnstructured added in v1.3.43 

func (m *RoleAuditDataMapper) ToUnstructured(roleAuditData *RoleAuditData) unstructured.Unstructured

type RoleMapper 

type RoleMapper struct {
}

func NewRoleMapper 

func NewRoleMapper() *RoleMapper

func (*RoleMapper) FromProperties 

func (m *RoleMapper) FromProperties(properties map[string]*structpb.Value) *Role

func (*RoleMapper) FromRecord 

func (m *RoleMapper) FromRecord(record *model.Record) *Role

func (*RoleMapper) New 

func (m *RoleMapper) New() *Role

func (*RoleMapper) ResourceIdentity 

func (m *RoleMapper) ResourceIdentity() abs.ResourceIdentity

func (*RoleMapper) ToProperties 

func (m *RoleMapper) ToProperties(role *Role) map[string]*structpb.Value

func (*RoleMapper) ToRecord 

func (m *RoleMapper) ToRecord(role *Role) *model.Record

func (*RoleMapper) ToUnstructured added in v1.3.43 

func (m *RoleMapper) ToUnstructured(role *Role) unstructured.Unstructured

type SubType added in v1.2.21 

type SubType struct {
	Name        string              `json:"name,omitempty"`
	Title       *string             `json:"title,omitempty"`
	Description *string             `json:"description,omitempty"`
	Properties  map[string]Property `json:"properties,omitempty"`
}

func (SubType) GetDescription added in v1.2.21 

func (s SubType) GetDescription() *string

func (SubType) GetName added in v1.2.21 

func (s SubType) GetName() string

func (SubType) GetProperties added in v1.2.21 

func (s SubType) GetProperties() map[string]Property

func (SubType) GetTitle added in v1.2.21 

func (s SubType) GetTitle() *string

type SubTypeMapper added in v1.2.21 

type SubTypeMapper struct {
}

func NewSubTypeMapper added in v1.2.21 

func NewSubTypeMapper() *SubTypeMapper

func (*SubTypeMapper) FromProperties added in v1.2.21 

func (m *SubTypeMapper) FromProperties(properties map[string]*structpb.Value) *SubType

func (*SubTypeMapper) New added in v1.2.21 

func (m *SubTypeMapper) New() *SubType

func (*SubTypeMapper) ResourceIdentity added in v1.2.21 

func (m *SubTypeMapper) ResourceIdentity() abs.ResourceIdentity

func (*SubTypeMapper) ToProperties added in v1.2.21 

func (m *SubTypeMapper) ToProperties(subType *SubType) map[string]*structpb.Value

func (*SubTypeMapper) ToUnstructured added in v1.3.43 

func (m *SubTypeMapper) ToUnstructured(subType *SubType) unstructured.Unstructured

type User 

type User struct {
	Id          *uuid.UUID     `json:"id,omitempty"`
	Version     int32          `json:"version,omitempty"`
	AuditData   *UserAuditData `json:"auditData,omitempty"`
	Username    string         `json:"username,omitempty"`
	Password    *string        `json:"password,omitempty"`
	Roles       []*Role        `json:"roles,omitempty"`
	Permissions []*Permission  `json:"permissions,omitempty"`
	Details     interface{}    `json:"details,omitempty"`
}

func (User) GetAuditData added in v1.2.36 

func (s User) GetAuditData() *UserAuditData

func (User) GetDetails 

func (s User) GetDetails() interface{}

func (User) GetId 

func (s User) GetId() *uuid.UUID

func (User) GetPassword 

func (s User) GetPassword() *string

func (User) GetPermissions added in v1.1.44 

func (s User) GetPermissions() []*Permission

func (User) GetRoles 

func (s User) GetRoles() []*Role

func (User) GetUsername 

func (s User) GetUsername() string

func (User) GetVersion 

func (s User) GetVersion() int32

type UserAuditData added in v1.2.36 

type UserAuditData struct {
	CreatedBy *string    `json:"createdBy,omitempty"`
	UpdatedBy *string    `json:"updatedBy,omitempty"`
	CreatedOn *time.Time `json:"createdOn,omitempty"`
	UpdatedOn *time.Time `json:"updatedOn,omitempty"`
}

func (UserAuditData) GetCreatedBy added in v1.2.36 

func (s UserAuditData) GetCreatedBy() *string

func (UserAuditData) GetCreatedOn added in v1.2.36 

func (s UserAuditData) GetCreatedOn() *time.Time

func (UserAuditData) GetUpdatedBy added in v1.2.36 

func (s UserAuditData) GetUpdatedBy() *string

func (UserAuditData) GetUpdatedOn added in v1.2.36 

func (s UserAuditData) GetUpdatedOn() *time.Time

type UserAuditDataMapper added in v1.2.36 

type UserAuditDataMapper struct {
}

func NewUserAuditDataMapper added in v1.2.36 

func NewUserAuditDataMapper() *UserAuditDataMapper

func (*UserAuditDataMapper) FromProperties added in v1.2.36 

func (m *UserAuditDataMapper) FromProperties(properties map[string]*structpb.Value) *UserAuditData

func (*UserAuditDataMapper) New added in v1.2.36 

func (m *UserAuditDataMapper) New() *UserAuditData

func (*UserAuditDataMapper) ResourceIdentity added in v1.2.36 

func (m *UserAuditDataMapper) ResourceIdentity() abs.ResourceIdentity

func (*UserAuditDataMapper) ToProperties added in v1.2.36 

func (m *UserAuditDataMapper) ToProperties(userAuditData *UserAuditData) map[string]*structpb.Value

func (*UserAuditDataMapper) ToUnstructured added in v1.3.43 

func (m *UserAuditDataMapper) ToUnstructured(userAuditData *UserAuditData) unstructured.Unstructured

type UserMapper 

type UserMapper struct {
}

func NewUserMapper 

func NewUserMapper() *UserMapper

func (*UserMapper) FromProperties 

func (m *UserMapper) FromProperties(properties map[string]*structpb.Value) *User

func (*UserMapper) FromRecord 

func (m *UserMapper) FromRecord(record *model.Record) *User

func (*UserMapper) New 

func (m *UserMapper) New() *User

func (*UserMapper) ResourceIdentity 

func (m *UserMapper) ResourceIdentity() abs.ResourceIdentity

func (*UserMapper) ToProperties 

func (m *UserMapper) ToProperties(user *User) map[string]*structpb.Value

func (*UserMapper) ToRecord 

func (m *UserMapper) ToRecord(user *User) *model.Record

func (*UserMapper) ToUnstructured added in v1.3.43 

func (m *UserMapper) ToUnstructured(user *User) unstructured.Unstructured

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.