graphql

package
v1.18.3 Latest Latest
Warning

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

 Go to latest Published: Jun 12, 2024 License: MIT Imports: 7 Imported by: 0

Documentation

Index

Constants

View Source 
const CreateSecretDocument = `` /* 159-byte string literal not displayed */
View Source 
const DeleteRefreshTokenDocument = `` /* 163-byte string literal not displayed */
View Source 
const DeleteSecretDocument = `mutation DeleteSecret ($appID: uuid!, $name: String!) {
	deleteSecret(appID: $appID, key: $name) {
		name
	}
}
`
View Source 
const GetConfigRawJSONDocument = `query GetConfigRawJSON ($appID: uuid!) {
	configRawJSON(appID: $appID, resolve: false)
}
`
View Source 
const GetHasuraAdminSecretDocument = `` /* 144-byte string literal not displayed */
View Source 
const GetRunServiceConfigRawJSONDocument = `` /* 174-byte string literal not displayed */
View Source 
const GetRunServiceInfoDocument = `query GetRunServiceInfo ($serviceID: uuid!) {
	runService(id: $serviceID) {
		appID
	}
}
`
View Source 
const GetSecretsDocument = `query GetSecrets ($appID: uuid!) {
	appSecrets(appID: $appID) {
		name
		value
	}
}
`
View Source 
const GetSoftwareVersionsDocument = `query GetSoftwareVersions {
	softwareVersions {
		software
		version
	}
}
`
View Source 
const GetWorkspacesAppsDocument = `query GetWorkspacesApps {
	workspaces {
		name
		apps {
			id
			name
			subdomain
			region {
				name
			}
		}
	}
}
`
View Source 
const ReplaceRunServiceConfigDocument = `` /* 215-byte string literal not displayed */
View Source 
const UpdateRunServiceConfigDocument = `` /* 213-byte string literal not displayed */
View Source 
const UpdateSecretDocument = `` /* 159-byte string literal not displayed */

Variables

View Source 
var AllAnnouncementsSelectColumn = []AnnouncementsSelectColumn{
	AnnouncementsSelectColumnContent,
	AnnouncementsSelectColumnCreatedAt,
	AnnouncementsSelectColumnExpiresAt,
	AnnouncementsSelectColumnHref,
	AnnouncementsSelectColumnID,
	AnnouncementsSelectColumnUpdatedAt,
}
View Source 
var AllAppStateHistorySelectColumn = []AppStateHistorySelectColumn{
	AppStateHistorySelectColumnAppID,
	AppStateHistorySelectColumnCreatedAt,
	AppStateHistorySelectColumnID,
	AppStateHistorySelectColumnMessage,
	AppStateHistorySelectColumnStateID,
}
View Source 
var AllAppsConstraint = []AppsConstraint{
	AppsConstraintAppsPkey,
	AppsConstraintAppsSubdomainKey,
	AppsConstraintAppsWorkspaceIDSlugKey,
}
View Source 
var AllAppsSelectColumn = []AppsSelectColumn{
	AppsSelectColumnCreatedAt,
	AppsSelectColumnCreatorUserID,
	AppsSelectColumnDesiredState,
	AppsSelectColumnGithubRepositoryID,
	AppsSelectColumnID,
	AppsSelectColumnIsLocked,
	AppsSelectColumnIsLockedReason,
	AppsSelectColumnMetadataFunctions,
	AppsSelectColumnName,
	AppsSelectColumnNhostBaseFolder,
	AppsSelectColumnRepositoryProductionBranch,
	AppsSelectColumnSlug,
	AppsSelectColumnSubdomain,
	AppsSelectColumnUpdatedAt,
	AppsSelectColumnWorkspaceID,
}
View Source 
var AllAppsUpdateColumn = []AppsUpdateColumn{
	AppsUpdateColumnDesiredState,
	AppsUpdateColumnGithubRepositoryID,
	AppsUpdateColumnName,
	AppsUpdateColumnNhostBaseFolder,
	AppsUpdateColumnPlanID,
	AppsUpdateColumnRepositoryProductionBranch,
	AppsUpdateColumnSlug,
}
View Source 
var AllAuthRefreshTokenTypesEnum = []AuthRefreshTokenTypesEnum{
	AuthRefreshTokenTypesEnumPat,
	AuthRefreshTokenTypesEnumRegular,
}
View Source 
var AllAuthRefreshTokensSelectColumn = []AuthRefreshTokensSelectColumn{
	AuthRefreshTokensSelectColumnCreatedAt,
	AuthRefreshTokensSelectColumnExpiresAt,
	AuthRefreshTokensSelectColumnID,
	AuthRefreshTokensSelectColumnMetadata,
	AuthRefreshTokensSelectColumnType,
	AuthRefreshTokensSelectColumnUserID,
}
View Source 
var AllAuthUserProvidersSelectColumn = []AuthUserProvidersSelectColumn{
	AuthUserProvidersSelectColumnID,
	AuthUserProvidersSelectColumnProviderID,
}
View Source 
var AllBackupsSelectColumn = []BackupsSelectColumn{
	BackupsSelectColumnAppID,
	BackupsSelectColumnCompletedAt,
	BackupsSelectColumnCreatedAt,
	BackupsSelectColumnID,
	BackupsSelectColumnSize,
}
View Source 
var AllCliTokensSelectColumn = []CliTokensSelectColumn{
	CliTokensSelectColumnCreatedAt,
	CliTokensSelectColumnID,
	CliTokensSelectColumnUpdatedAt,
}
View Source 
var AllContinentsSelectColumn = []ContinentsSelectColumn{
	ContinentsSelectColumnCode,
	ContinentsSelectColumnName,
}
View Source 
var AllCountriesSelectColumn = []CountriesSelectColumn{
	CountriesSelectColumnCode,
	CountriesSelectColumnContinentCode,
	CountriesSelectColumnEmojiFlag,
	CountriesSelectColumnName,
}
View Source 
var AllCursorOrdering = []CursorOrdering{
	CursorOrderingAsc,
	CursorOrderingDesc,
}
View Source 
var AllDeploymentLogsSelectColumn = []DeploymentLogsSelectColumn{
	DeploymentLogsSelectColumnCreatedAt,
	DeploymentLogsSelectColumnDeploymentID,
	DeploymentLogsSelectColumnID,
	DeploymentLogsSelectColumnMessage,
}
View Source 
var AllDeploymentsConstraint = []DeploymentsConstraint{
	DeploymentsConstraintDeploymentsPkey,
}
View Source 
var AllDeploymentsSelectColumn = []DeploymentsSelectColumn{
	DeploymentsSelectColumnAppID,
	DeploymentsSelectColumnCommitMessage,
	DeploymentsSelectColumnCommitSha,
	DeploymentsSelectColumnCommitUserAvatarURL,
	DeploymentsSelectColumnCommitUserName,
	DeploymentsSelectColumnDeploymentEndedAt,
	DeploymentsSelectColumnDeploymentStartedAt,
	DeploymentsSelectColumnDeploymentStatus,
	DeploymentsSelectColumnFunctionsEndedAt,
	DeploymentsSelectColumnFunctionsStartedAt,
	DeploymentsSelectColumnFunctionsStatus,
	DeploymentsSelectColumnID,
	DeploymentsSelectColumnMetadataEndedAt,
	DeploymentsSelectColumnMetadataStartedAt,
	DeploymentsSelectColumnMetadataStatus,
	DeploymentsSelectColumnMigrationsEndedAt,
	DeploymentsSelectColumnMigrationsStartedAt,
	DeploymentsSelectColumnMigrationsStatus,
}
View Source 
var AllDeploymentsUpdateColumn = []DeploymentsUpdateColumn{
	DeploymentsUpdateColumnPlaceholder,
}
View Source 
var AllFeatureFlagsConstraint = []FeatureFlagsConstraint{
	FeatureFlagsConstraintFeatureFlagsPkey,
}
View Source 
var AllFeatureFlagsSelectColumn = []FeatureFlagsSelectColumn{
	FeatureFlagsSelectColumnAppID,
	FeatureFlagsSelectColumnDescription,
	FeatureFlagsSelectColumnID,
	FeatureFlagsSelectColumnName,
	FeatureFlagsSelectColumnValue,
}
View Source 
var AllFeatureFlagsUpdateColumn = []FeatureFlagsUpdateColumn{
	FeatureFlagsUpdateColumnPlaceholder,
}
View Source 
var AllGithubAppInstallationsConstraint = []GithubAppInstallationsConstraint{
	GithubAppInstallationsConstraintGithubAppInstallationsExternalGithubAppInstallationIKey,
	GithubAppInstallationsConstraintGithubAppInstallationsPkey,
}
View Source 
var AllGithubAppInstallationsSelectColumn = []GithubAppInstallationsSelectColumn{
	GithubAppInstallationsSelectColumnAccountAvatarURL,
	GithubAppInstallationsSelectColumnAccountLogin,
	GithubAppInstallationsSelectColumnAccountType,
	GithubAppInstallationsSelectColumnCreatedAt,
	GithubAppInstallationsSelectColumnID,
	GithubAppInstallationsSelectColumnUpdatedAt,
}
View Source 
var AllGithubAppInstallationsUpdateColumn = []GithubAppInstallationsUpdateColumn{
	GithubAppInstallationsUpdateColumnPlaceholder,
}
View Source 
var AllGithubRepositoriesSelectColumn = []GithubRepositoriesSelectColumn{
	GithubRepositoriesSelectColumnCreatedAt,
	GithubRepositoriesSelectColumnFullName,
	GithubRepositoriesSelectColumnID,
	GithubRepositoriesSelectColumnName,
	GithubRepositoriesSelectColumnPrivate,
	GithubRepositoriesSelectColumnUpdatedAt,
}
View Source 
var AllOrderBy = []OrderBy{
	OrderByAsc,
	OrderByAscNullsFirst,
	OrderByAscNullsLast,
	OrderByDesc,
	OrderByDescNullsFirst,
	OrderByDescNullsLast,
}
View Source 
var AllPaymentMethodsConstraint = []PaymentMethodsConstraint{
	PaymentMethodsConstraintPaymentMethodsPkey,
}
View Source 
var AllPaymentMethodsSelectColumn = []PaymentMethodsSelectColumn{
	PaymentMethodsSelectColumnAddedByUserID,
	PaymentMethodsSelectColumnCardBrand,
	PaymentMethodsSelectColumnCardExpMonth,
	PaymentMethodsSelectColumnCardExpYear,
	PaymentMethodsSelectColumnCardLast4,
	PaymentMethodsSelectColumnCreatedAt,
	PaymentMethodsSelectColumnID,
	PaymentMethodsSelectColumnIsDefault,
	PaymentMethodsSelectColumnStripePaymentMethodID,
	PaymentMethodsSelectColumnWorkspaceID,
}
View Source 
var AllPaymentMethodsUpdateColumn = []PaymentMethodsUpdateColumn{
	PaymentMethodsUpdateColumnIsDefault,
}
View Source 
var AllPlansSelectColumn = []PlansSelectColumn{
	PlansSelectColumnCreatedAt,
	PlansSelectColumnDeprecated,
	PlansSelectColumnFeatureBackupEnabled,
	PlansSelectColumnFeatureCustomDomainsEnabled,
	PlansSelectColumnFeatureCustomEmailTemplatesEnabled,
	PlansSelectColumnFeatureMaxDbSize,
	PlansSelectColumnID,
	PlansSelectColumnIndividual,
	PlansSelectColumnIsDefault,
	PlansSelectColumnIsFree,
	PlansSelectColumnName,
	PlansSelectColumnPrice,
	PlansSelectColumnSort,
	PlansSelectColumnUpatedAt,
}
View Source 
var AllRegionTypeEnum = []RegionTypeEnum{
	RegionTypeEnumPrivate,
	RegionTypeEnumPublic,
}
View Source 
var AllRegionsAllowedWorkspaceSelectColumn = []RegionsAllowedWorkspaceSelectColumn{
	RegionsAllowedWorkspaceSelectColumnCreatedAt,
	RegionsAllowedWorkspaceSelectColumnDescription,
	RegionsAllowedWorkspaceSelectColumnID,
	RegionsAllowedWorkspaceSelectColumnRegionID,
	RegionsAllowedWorkspaceSelectColumnUpdatedAt,
	RegionsAllowedWorkspaceSelectColumnWorkspaceID,
}
View Source 
var AllRegionsSelectColumn = []RegionsSelectColumn{
	RegionsSelectColumnActive,
	RegionsSelectColumnAwsName,
	RegionsSelectColumnCity,
	RegionsSelectColumnCountryCode,
	RegionsSelectColumnDescription,
	RegionsSelectColumnDomain,
	RegionsSelectColumnID,
	RegionsSelectColumnIsGdprCompliant,
	RegionsSelectColumnName,
	RegionsSelectColumnType,
}
View Source 
var AllRunServiceConstraint = []RunServiceConstraint{
	RunServiceConstraintRunServicePkey,
	RunServiceConstraintRunServiceSubdomainKey,
}
View Source 
var AllRunServiceSelectColumn = []RunServiceSelectColumn{
	RunServiceSelectColumnAppID,
	RunServiceSelectColumnCreatedAt,
	RunServiceSelectColumnCreatorUserID,
	RunServiceSelectColumnID,
	RunServiceSelectColumnSubdomain,
	RunServiceSelectColumnUpdatedAt,
}
View Source 
var AllRunServiceUpdateColumn = []RunServiceUpdateColumn{
	RunServiceUpdateColumnPlaceholder,
}
View Source 
var AllServiceState = []ServiceState{
	ServiceStateError,
	ServiceStateNone,
	ServiceStateRunning,
	ServiceStateUpdateError,
	ServiceStateUpdating,
}
View Source 
var AllSoftwareTypeEnum = []SoftwareTypeEnum{
	SoftwareTypeEnumAuth,
	SoftwareTypeEnumGraphite,
	SoftwareTypeEnumHasura,
	SoftwareTypeEnumPostgreSQL,
	SoftwareTypeEnumStorage,
}
View Source 
var AllSoftwareVersionsSelectColumn = []SoftwareVersionsSelectColumn{
	SoftwareVersionsSelectColumnID,
	SoftwareVersionsSelectColumnSoftware,
	SoftwareVersionsSelectColumnVersion,
}
View Source 
var AllUsersSelectColumn = []UsersSelectColumn{
	UsersSelectColumnAvatarURL,
	UsersSelectColumnDisplayName,
	UsersSelectColumnEmail,
	UsersSelectColumnID,
}
View Source 
var AllUsersUsageSelectColumn = []UsersUsageSelectColumn{
	UsersUsageSelectColumnCreatedAt,
	UsersUsageSelectColumnFreeAllowanceExceeded,
	UsersUsageSelectColumnID,
	UsersUsageSelectColumnUpdatedAt,
	UsersUsageSelectColumnUserID,
}
View Source 
var AllWorkspaceMemberInvitesConstraint = []WorkspaceMemberInvitesConstraint{
	WorkspaceMemberInvitesConstraintWorkspaceMemberInvitesEmailWorkspaceIDKey,
	WorkspaceMemberInvitesConstraintWorkspaceMemberInvitesPkey,
}
View Source 
var AllWorkspaceMemberInvitesSelectColumn = []WorkspaceMemberInvitesSelectColumn{
	WorkspaceMemberInvitesSelectColumnCreatedAt,
	WorkspaceMemberInvitesSelectColumnEmail,
	WorkspaceMemberInvitesSelectColumnID,
	WorkspaceMemberInvitesSelectColumnInvitedByUserID,
	WorkspaceMemberInvitesSelectColumnMemberType,
	WorkspaceMemberInvitesSelectColumnUpdatedAt,
	WorkspaceMemberInvitesSelectColumnWorkspaceID,
}
View Source 
var AllWorkspaceMemberInvitesUpdateColumn = []WorkspaceMemberInvitesUpdateColumn{
	WorkspaceMemberInvitesUpdateColumnMemberType,
}
View Source 
var AllWorkspaceMembersConstraint = []WorkspaceMembersConstraint{
	WorkspaceMembersConstraintWorkspaceMembersPkey,
	WorkspaceMembersConstraintWorkspaceMembersUserIDWorkspaceIDKey,
}
View Source 
var AllWorkspaceMembersSelectColumn = []WorkspaceMembersSelectColumn{
	WorkspaceMembersSelectColumnCreatedAt,
	WorkspaceMembersSelectColumnID,
	WorkspaceMembersSelectColumnType,
	WorkspaceMembersSelectColumnUpdatedAt,
	WorkspaceMembersSelectColumnUserID,
	WorkspaceMembersSelectColumnWorkspaceID,
}
View Source 
var AllWorkspaceMembersUpdateColumn = []WorkspaceMembersUpdateColumn{
	WorkspaceMembersUpdateColumnType,
}
View Source 
var AllWorkspacesConstraint = []WorkspacesConstraint{
	WorkspacesConstraintWorkspacesPkey,
	WorkspacesConstraintWorkspacesSlugKey,
}
View Source 
var AllWorkspacesSelectColumn = []WorkspacesSelectColumn{
	WorkspacesSelectColumnAddressCity,
	WorkspacesSelectColumnAddressCountryCode,
	WorkspacesSelectColumnAddressLine1,
	WorkspacesSelectColumnAddressLine2,
	WorkspacesSelectColumnAddressPostalCode,
	WorkspacesSelectColumnAddressState,
	WorkspacesSelectColumnCompanyName,
	WorkspacesSelectColumnCreatedAt,
	WorkspacesSelectColumnCreatorUserID,
	WorkspacesSelectColumnEmail,
	WorkspacesSelectColumnID,
	WorkspacesSelectColumnName,
	WorkspacesSelectColumnSlug,
	WorkspacesSelectColumnTaxIDType,
	WorkspacesSelectColumnTaxIDValue,
	WorkspacesSelectColumnUpdatedAt,
}
View Source 
var AllWorkspacesUpdateColumn = []WorkspacesUpdateColumn{
	WorkspacesUpdateColumnAddressCity,
	WorkspacesUpdateColumnAddressCountryCode,
	WorkspacesUpdateColumnAddressLine1,
	WorkspacesUpdateColumnAddressLine2,
	WorkspacesUpdateColumnAddressPostalCode,
	WorkspacesUpdateColumnAddressState,
	WorkspacesUpdateColumnCompanyName,
	WorkspacesUpdateColumnEmail,
	WorkspacesUpdateColumnName,
	WorkspacesUpdateColumnSlug,
	WorkspacesUpdateColumnTaxIDType,
	WorkspacesUpdateColumnTaxIDValue,
}
View Source 
var DocumentOperationNames = map[string]string{
	GetWorkspacesAppsDocument:          "GetWorkspacesApps",
	GetHasuraAdminSecretDocument:       "GetHasuraAdminSecret",
	GetConfigRawJSONDocument:           "GetConfigRawJSON",
	DeleteRefreshTokenDocument:         "DeleteRefreshToken",
	GetSecretsDocument:                 "GetSecrets",
	CreateSecretDocument:               "CreateSecret",
	DeleteSecretDocument:               "DeleteSecret",
	UpdateSecretDocument:               "UpdateSecret",
	UpdateRunServiceConfigDocument:     "UpdateRunServiceConfig",
	ReplaceRunServiceConfigDocument:    "ReplaceRunServiceConfig",
	GetRunServiceInfoDocument:          "GetRunServiceInfo",
	GetRunServiceConfigRawJSONDocument: "GetRunServiceConfigRawJSON",
	GetSoftwareVersionsDocument:        "GetSoftwareVersions",
}

Functions

func WithAccessToken 

func WithAccessToken(accessToken string) clientv2.RequestInterceptor

Types

type Announcements added in v1.9.3 

type Announcements struct {
	Content   string     `json:"content"`
	CreatedAt time.Time  `json:"createdAt"`
	ExpiresAt *time.Time `json:"expiresAt,omitempty"`
	Href      string     `json:"href"`
	ID        string     `json:"id"`
	UpdatedAt time.Time  `json:"updatedAt"`
}

columns and relationships of "announcements"

type AnnouncementsBoolExp added in v1.9.3 

type AnnouncementsBoolExp struct {
	And       []*AnnouncementsBoolExp   `json:"_and,omitempty"`
	Not       *AnnouncementsBoolExp     `json:"_not,omitempty"`
	Or        []*AnnouncementsBoolExp   `json:"_or,omitempty"`
	Content   *StringComparisonExp      `json:"content,omitempty"`
	CreatedAt *TimestamptzComparisonExp `json:"createdAt,omitempty"`
	ExpiresAt *TimestamptzComparisonExp `json:"expiresAt,omitempty"`
	Href      *StringComparisonExp      `json:"href,omitempty"`
	ID        *UUIDComparisonExp        `json:"id,omitempty"`
	UpdatedAt *TimestamptzComparisonExp `json:"updatedAt,omitempty"`
}

Boolean expression to filter rows from the table "announcements". All fields are combined with a logical 'AND'.

type AnnouncementsOrderBy added in v1.9.3 

type AnnouncementsOrderBy struct {
	Content   *OrderBy `json:"content,omitempty"`
	CreatedAt *OrderBy `json:"createdAt,omitempty"`
	ExpiresAt *OrderBy `json:"expiresAt,omitempty"`
	Href      *OrderBy `json:"href,omitempty"`
	ID        *OrderBy `json:"id,omitempty"`
	UpdatedAt *OrderBy `json:"updatedAt,omitempty"`
}

Ordering options when selecting data from "announcements".

type AnnouncementsSelectColumn added in v1.9.3 

type AnnouncementsSelectColumn string

select columns of table "announcements" 

const (
	// column name
	AnnouncementsSelectColumnContent AnnouncementsSelectColumn = "content"
	// column name
	AnnouncementsSelectColumnCreatedAt AnnouncementsSelectColumn = "createdAt"
	// column name
	AnnouncementsSelectColumnExpiresAt AnnouncementsSelectColumn = "expiresAt"
	// column name
	AnnouncementsSelectColumnHref AnnouncementsSelectColumn = "href"
	// column name
	AnnouncementsSelectColumnID AnnouncementsSelectColumn = "id"
	// column name
	AnnouncementsSelectColumnUpdatedAt AnnouncementsSelectColumn = "updatedAt"
)

func (AnnouncementsSelectColumn) IsValid added in v1.9.3 

func (e AnnouncementsSelectColumn) IsValid() bool

func (AnnouncementsSelectColumn) MarshalGQL added in v1.9.3 

func (e AnnouncementsSelectColumn) MarshalGQL(w io.Writer)

func (AnnouncementsSelectColumn) String added in v1.9.3 

func (e AnnouncementsSelectColumn) String() string

func (*AnnouncementsSelectColumn) UnmarshalGQL added in v1.9.3 

func (e *AnnouncementsSelectColumn) UnmarshalGQL(v interface{}) error

type AnnouncementsStreamCursorInput added in v1.9.3 

type AnnouncementsStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *AnnouncementsStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "announcements"

type AnnouncementsStreamCursorValueInput added in v1.9.3 

type AnnouncementsStreamCursorValueInput struct {
	Content   *string    `json:"content,omitempty"`
	CreatedAt *time.Time `json:"createdAt,omitempty"`
	ExpiresAt *time.Time `json:"expiresAt,omitempty"`
	Href      *string    `json:"href,omitempty"`
	ID        *string    `json:"id,omitempty"`
	UpdatedAt *time.Time `json:"updatedAt,omitempty"`
}

Initial value of the column from where the streaming should start

type AppStateHistory 

type AppStateHistory struct {
	// An object relationship
	App       *Apps     `json:"app"`
	AppID     string    `json:"appId"`
	CreatedAt time.Time `json:"createdAt"`
	ID        string    `json:"id"`
	Message   *string   `json:"message,omitempty"`
	StateID   int64     `json:"stateId"`
}

columns and relationships of "app_state_history"

type AppStateHistoryAggregateOrderBy 

type AppStateHistoryAggregateOrderBy struct {
	Avg        *AppStateHistoryAvgOrderBy        `json:"avg,omitempty"`
	Count      *OrderBy                          `json:"count,omitempty"`
	Max        *AppStateHistoryMaxOrderBy        `json:"max,omitempty"`
	Min        *AppStateHistoryMinOrderBy        `json:"min,omitempty"`
	Stddev     *AppStateHistoryStddevOrderBy     `json:"stddev,omitempty"`
	StddevPop  *AppStateHistoryStddevPopOrderBy  `json:"stddev_pop,omitempty"`
	StddevSamp *AppStateHistoryStddevSampOrderBy `json:"stddev_samp,omitempty"`
	Sum        *AppStateHistorySumOrderBy        `json:"sum,omitempty"`
	VarPop     *AppStateHistoryVarPopOrderBy     `json:"var_pop,omitempty"`
	VarSamp    *AppStateHistoryVarSampOrderBy    `json:"var_samp,omitempty"`
	Variance   *AppStateHistoryVarianceOrderBy   `json:"variance,omitempty"`
}

order by aggregate values of table "app_state_history"

type AppStateHistoryAvgOrderBy 

type AppStateHistoryAvgOrderBy struct {
	StateID *OrderBy `json:"stateId,omitempty"`
}

order by avg() on columns of table "app_state_history"

type AppStateHistoryBoolExp 

type AppStateHistoryBoolExp struct {
	And       []*AppStateHistoryBoolExp `json:"_and,omitempty"`
	Not       *AppStateHistoryBoolExp   `json:"_not,omitempty"`
	Or        []*AppStateHistoryBoolExp `json:"_or,omitempty"`
	App       *AppsBoolExp              `json:"app,omitempty"`
	AppID     *UUIDComparisonExp        `json:"appId,omitempty"`
	CreatedAt *TimestamptzComparisonExp `json:"createdAt,omitempty"`
	ID        *UUIDComparisonExp        `json:"id,omitempty"`
	Message   *StringComparisonExp      `json:"message,omitempty"`
	StateID   *IntComparisonExp         `json:"stateId,omitempty"`
}

Boolean expression to filter rows from the table "app_state_history". All fields are combined with a logical 'AND'.

type AppStateHistoryMaxOrderBy 

type AppStateHistoryMaxOrderBy struct {
	AppID     *OrderBy `json:"appId,omitempty"`
	CreatedAt *OrderBy `json:"createdAt,omitempty"`
	ID        *OrderBy `json:"id,omitempty"`
	Message   *OrderBy `json:"message,omitempty"`
	StateID   *OrderBy `json:"stateId,omitempty"`
}

order by max() on columns of table "app_state_history"

type AppStateHistoryMinOrderBy 

type AppStateHistoryMinOrderBy struct {
	AppID     *OrderBy `json:"appId,omitempty"`
	CreatedAt *OrderBy `json:"createdAt,omitempty"`
	ID        *OrderBy `json:"id,omitempty"`
	Message   *OrderBy `json:"message,omitempty"`
	StateID   *OrderBy `json:"stateId,omitempty"`
}

order by min() on columns of table "app_state_history"

type AppStateHistoryOrderBy 

type AppStateHistoryOrderBy struct {
	App       *AppsOrderBy `json:"app,omitempty"`
	AppID     *OrderBy     `json:"appId,omitempty"`
	CreatedAt *OrderBy     `json:"createdAt,omitempty"`
	ID        *OrderBy     `json:"id,omitempty"`
	Message   *OrderBy     `json:"message,omitempty"`
	StateID   *OrderBy     `json:"stateId,omitempty"`
}

Ordering options when selecting data from "app_state_history".

type AppStateHistorySelectColumn 

type AppStateHistorySelectColumn string

select columns of table "app_state_history" 

const (
	// column name
	AppStateHistorySelectColumnAppID AppStateHistorySelectColumn = "appId"
	// column name
	AppStateHistorySelectColumnCreatedAt AppStateHistorySelectColumn = "createdAt"
	// column name
	AppStateHistorySelectColumnID AppStateHistorySelectColumn = "id"
	// column name
	AppStateHistorySelectColumnMessage AppStateHistorySelectColumn = "message"
	// column name
	AppStateHistorySelectColumnStateID AppStateHistorySelectColumn = "stateId"
)

func (AppStateHistorySelectColumn) IsValid 

func (e AppStateHistorySelectColumn) IsValid() bool

func (AppStateHistorySelectColumn) MarshalGQL 

func (e AppStateHistorySelectColumn) MarshalGQL(w io.Writer)

func (AppStateHistorySelectColumn) String 

func (e AppStateHistorySelectColumn) String() string

func (*AppStateHistorySelectColumn) UnmarshalGQL 

func (e *AppStateHistorySelectColumn) UnmarshalGQL(v interface{}) error

type AppStateHistoryStddevOrderBy 

type AppStateHistoryStddevOrderBy struct {
	StateID *OrderBy `json:"stateId,omitempty"`
}

order by stddev() on columns of table "app_state_history"

type AppStateHistoryStddevPopOrderBy 

type AppStateHistoryStddevPopOrderBy struct {
	StateID *OrderBy `json:"stateId,omitempty"`
}

order by stddev_pop() on columns of table "app_state_history"

type AppStateHistoryStddevSampOrderBy 

type AppStateHistoryStddevSampOrderBy struct {
	StateID *OrderBy `json:"stateId,omitempty"`
}

order by stddev_samp() on columns of table "app_state_history"

type AppStateHistoryStreamCursorInput 

type AppStateHistoryStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *AppStateHistoryStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "appStateHistory"

type AppStateHistoryStreamCursorValueInput 

type AppStateHistoryStreamCursorValueInput struct {
	AppID     *string    `json:"appId,omitempty"`
	CreatedAt *time.Time `json:"createdAt,omitempty"`
	ID        *string    `json:"id,omitempty"`
	Message   *string    `json:"message,omitempty"`
	StateID   *int64     `json:"stateId,omitempty"`
}

Initial value of the column from where the streaming should start

type AppStateHistorySumOrderBy 

type AppStateHistorySumOrderBy struct {
	StateID *OrderBy `json:"stateId,omitempty"`
}

order by sum() on columns of table "app_state_history"

type AppStateHistoryVarPopOrderBy 

type AppStateHistoryVarPopOrderBy struct {
	StateID *OrderBy `json:"stateId,omitempty"`
}

order by var_pop() on columns of table "app_state_history"

type AppStateHistoryVarSampOrderBy 

type AppStateHistoryVarSampOrderBy struct {
	StateID *OrderBy `json:"stateId,omitempty"`
}

order by var_samp() on columns of table "app_state_history"

type AppStateHistoryVarianceOrderBy 

type AppStateHistoryVarianceOrderBy struct {
	StateID *OrderBy `json:"stateId,omitempty"`
}

order by variance() on columns of table "app_state_history"

type Apps 

type Apps struct {
	AppSecrets []*ConfigEnvironmentVariable `json:"appSecrets"`
	// An array relationship
	AppStates []*AppStateHistory `json:"appStates"`
	// An array relationship
	Backups   []*Backups    `json:"backups"`
	Config    *ConfigConfig `json:"config,omitempty"`
	CreatedAt time.Time     `json:"createdAt"`
	// An object relationship
	Creator       *Users  `json:"creator,omitempty"`
	CreatorUserID *string `json:"creatorUserId,omitempty"`
	// An array relationship
	Deployments  []*Deployments `json:"deployments"`
	DesiredState int64          `json:"desiredState"`
	// An array relationship
	FeatureFlags []*FeatureFlags `json:"featureFlags"`
	// An object relationship
	GithubRepository   *GithubRepositories    `json:"githubRepository,omitempty"`
	GithubRepositoryID *string                `json:"githubRepositoryId,omitempty"`
	ID                 string                 `json:"id"`
	IsLocked           *bool                  `json:"isLocked,omitempty"`
	IsLockedReason     *string                `json:"isLockedReason,omitempty"`
	MetadataFunctions  map[string]interface{} `json:"metadataFunctions"`
	Name               string                 `json:"name"`
	NhostBaseFolder    string                 `json:"nhostBaseFolder"`
	// An object relationship
	Plan *Plans `json:"plan"`
	// An object relationship
	Region                     *Regions `json:"region"`
	RepositoryProductionBranch string   `json:"repositoryProductionBranch"`
	// An array relationship
	RunServices []*RunService `json:"runServices"`
	// An aggregate relationship
	RunServicesAggregate *RunServiceAggregate `json:"runServices_aggregate"`
	Slug                 string               `json:"slug"`
	Subdomain            string               `json:"subdomain"`
	SystemConfig         *ConfigSystemConfig  `json:"systemConfig,omitempty"`
	UpdatedAt            time.Time            `json:"updatedAt"`
	// An object relationship
	Workspace   *Workspaces `json:"workspace"`
	WorkspaceID string      `json:"workspaceId"`
}

columns and relationships of "apps"

type AppsAggregateOrderBy 

type AppsAggregateOrderBy struct {
	Avg        *AppsAvgOrderBy        `json:"avg,omitempty"`
	Count      *OrderBy               `json:"count,omitempty"`
	Max        *AppsMaxOrderBy        `json:"max,omitempty"`
	Min        *AppsMinOrderBy        `json:"min,omitempty"`
	Stddev     *AppsStddevOrderBy     `json:"stddev,omitempty"`
	StddevPop  *AppsStddevPopOrderBy  `json:"stddev_pop,omitempty"`
	StddevSamp *AppsStddevSampOrderBy `json:"stddev_samp,omitempty"`
	Sum        *AppsSumOrderBy        `json:"sum,omitempty"`
	VarPop     *AppsVarPopOrderBy     `json:"var_pop,omitempty"`
	VarSamp    *AppsVarSampOrderBy    `json:"var_samp,omitempty"`
	Variance   *AppsVarianceOrderBy   `json:"variance,omitempty"`
}

order by aggregate values of table "apps"

type AppsArrRelInsertInput 

type AppsArrRelInsertInput struct {
	Data []*AppsInsertInput `json:"data"`
	// upsert condition
	OnConflict *AppsOnConflict `json:"on_conflict,omitempty"`
}

input type for inserting array relation for remote table "apps"

type AppsAvgOrderBy 

type AppsAvgOrderBy struct {
	DesiredState *OrderBy `json:"desiredState,omitempty"`
}

order by avg() on columns of table "apps"

type AppsBoolExp 

type AppsBoolExp struct {
	And                        []*AppsBoolExp              `json:"_and,omitempty"`
	Not                        *AppsBoolExp                `json:"_not,omitempty"`
	Or                         []*AppsBoolExp              `json:"_or,omitempty"`
	AppStates                  *AppStateHistoryBoolExp     `json:"appStates,omitempty"`
	Backups                    *BackupsBoolExp             `json:"backups,omitempty"`
	CreatedAt                  *TimestamptzComparisonExp   `json:"createdAt,omitempty"`
	Creator                    *UsersBoolExp               `json:"creator,omitempty"`
	CreatorUserID              *UUIDComparisonExp          `json:"creatorUserId,omitempty"`
	Deployments                *DeploymentsBoolExp         `json:"deployments,omitempty"`
	DesiredState               *IntComparisonExp           `json:"desiredState,omitempty"`
	FeatureFlags               *FeatureFlagsBoolExp        `json:"featureFlags,omitempty"`
	GithubRepository           *GithubRepositoriesBoolExp  `json:"githubRepository,omitempty"`
	GithubRepositoryID         *UUIDComparisonExp          `json:"githubRepositoryId,omitempty"`
	ID                         *UUIDComparisonExp          `json:"id,omitempty"`
	IsLocked                   *BooleanComparisonExp       `json:"isLocked,omitempty"`
	IsLockedReason             *StringComparisonExp        `json:"isLockedReason,omitempty"`
	MetadataFunctions          *JsonbComparisonExp         `json:"metadataFunctions,omitempty"`
	Name                       *StringComparisonExp        `json:"name,omitempty"`
	NhostBaseFolder            *StringComparisonExp        `json:"nhostBaseFolder,omitempty"`
	Plan                       *PlansBoolExp               `json:"plan,omitempty"`
	Region                     *RegionsBoolExp             `json:"region,omitempty"`
	RepositoryProductionBranch *StringComparisonExp        `json:"repositoryProductionBranch,omitempty"`
	RunServices                *RunServiceBoolExp          `json:"runServices,omitempty"`
	RunServicesAggregate       *RunServiceAggregateBoolExp `json:"runServices_aggregate,omitempty"`
	Slug                       *StringComparisonExp        `json:"slug,omitempty"`
	Subdomain                  *StringComparisonExp        `json:"subdomain,omitempty"`
	UpdatedAt                  *TimestamptzComparisonExp   `json:"updatedAt,omitempty"`
	Workspace                  *WorkspacesBoolExp          `json:"workspace,omitempty"`
	WorkspaceID                *UUIDComparisonExp          `json:"workspaceId,omitempty"`
}

Boolean expression to filter rows from the table "apps". All fields are combined with a logical 'AND'.

type AppsConstraint 

type AppsConstraint string

unique or primary key constraints on table "apps" 

const (
	// unique or primary key constraint on columns "id"
	AppsConstraintAppsPkey AppsConstraint = "apps_pkey"
	// unique or primary key constraint on columns "subdomain"
	AppsConstraintAppsSubdomainKey AppsConstraint = "apps_subdomain_key"
	// unique or primary key constraint on columns "workspace_id", "slug"
	AppsConstraintAppsWorkspaceIDSlugKey AppsConstraint = "apps_workspace_id_slug_key"
)

func (AppsConstraint) IsValid 

func (e AppsConstraint) IsValid() bool

func (AppsConstraint) MarshalGQL 

func (e AppsConstraint) MarshalGQL(w io.Writer)

func (AppsConstraint) String 

func (e AppsConstraint) String() string

func (*AppsConstraint) UnmarshalGQL 

func (e *AppsConstraint) UnmarshalGQL(v interface{}) error

type AppsIncInput 

type AppsIncInput struct {
	DesiredState *int64 `json:"desiredState,omitempty"`
}

input type for incrementing numeric columns in table "apps"

type AppsInsertInput 

type AppsInsertInput struct {
	Deployments  *DeploymentsArrRelInsertInput  `json:"deployments,omitempty"`
	FeatureFlags *FeatureFlagsArrRelInsertInput `json:"featureFlags,omitempty"`
	Name         *string                        `json:"name,omitempty"`
	PlanID       *string                        `json:"planId,omitempty"`
	RegionID     *string                        `json:"regionId,omitempty"`
	RunServices  *RunServiceArrRelInsertInput   `json:"runServices,omitempty"`
	Slug         *string                        `json:"slug,omitempty"`
	Workspace    *WorkspacesObjRelInsertInput   `json:"workspace,omitempty"`
	WorkspaceID  *string                        `json:"workspaceId,omitempty"`
}

input type for inserting data into table "apps"

type AppsMaxOrderBy 

type AppsMaxOrderBy struct {
	CreatedAt                  *OrderBy `json:"createdAt,omitempty"`
	CreatorUserID              *OrderBy `json:"creatorUserId,omitempty"`
	DesiredState               *OrderBy `json:"desiredState,omitempty"`
	GithubRepositoryID         *OrderBy `json:"githubRepositoryId,omitempty"`
	ID                         *OrderBy `json:"id,omitempty"`
	IsLockedReason             *OrderBy `json:"isLockedReason,omitempty"`
	Name                       *OrderBy `json:"name,omitempty"`
	NhostBaseFolder            *OrderBy `json:"nhostBaseFolder,omitempty"`
	RepositoryProductionBranch *OrderBy `json:"repositoryProductionBranch,omitempty"`
	Slug                       *OrderBy `json:"slug,omitempty"`
	Subdomain                  *OrderBy `json:"subdomain,omitempty"`
	UpdatedAt                  *OrderBy `json:"updatedAt,omitempty"`
	WorkspaceID                *OrderBy `json:"workspaceId,omitempty"`
}

order by max() on columns of table "apps"

type AppsMinOrderBy 

type AppsMinOrderBy struct {
	CreatedAt                  *OrderBy `json:"createdAt,omitempty"`
	CreatorUserID              *OrderBy `json:"creatorUserId,omitempty"`
	DesiredState               *OrderBy `json:"desiredState,omitempty"`
	GithubRepositoryID         *OrderBy `json:"githubRepositoryId,omitempty"`
	ID                         *OrderBy `json:"id,omitempty"`
	IsLockedReason             *OrderBy `json:"isLockedReason,omitempty"`
	Name                       *OrderBy `json:"name,omitempty"`
	NhostBaseFolder            *OrderBy `json:"nhostBaseFolder,omitempty"`
	RepositoryProductionBranch *OrderBy `json:"repositoryProductionBranch,omitempty"`
	Slug                       *OrderBy `json:"slug,omitempty"`
	Subdomain                  *OrderBy `json:"subdomain,omitempty"`
	UpdatedAt                  *OrderBy `json:"updatedAt,omitempty"`
	WorkspaceID                *OrderBy `json:"workspaceId,omitempty"`
}

order by min() on columns of table "apps"

type AppsMutationResponse 

type AppsMutationResponse struct {
	// number of rows affected by the mutation
	AffectedRows int64 `json:"affected_rows"`
	// data from the rows affected by the mutation
	Returning []*Apps `json:"returning"`
}

response of any mutation on the table "apps"

type AppsObjRelInsertInput 

type AppsObjRelInsertInput struct {
	Data *AppsInsertInput `json:"data"`
	// upsert condition
	OnConflict *AppsOnConflict `json:"on_conflict,omitempty"`
}

input type for inserting object relation for remote table "apps"

type AppsOnConflict 

type AppsOnConflict struct {
	Constraint    AppsConstraint     `json:"constraint"`
	UpdateColumns []AppsUpdateColumn `json:"update_columns"`
	Where         *AppsBoolExp       `json:"where,omitempty"`
}

on_conflict condition type for table "apps"

type AppsOrderBy 

type AppsOrderBy struct {
	AppStatesAggregate         *AppStateHistoryAggregateOrderBy `json:"appStates_aggregate,omitempty"`
	BackupsAggregate           *BackupsAggregateOrderBy         `json:"backups_aggregate,omitempty"`
	CreatedAt                  *OrderBy                         `json:"createdAt,omitempty"`
	Creator                    *UsersOrderBy                    `json:"creator,omitempty"`
	CreatorUserID              *OrderBy                         `json:"creatorUserId,omitempty"`
	DeploymentsAggregate       *DeploymentsAggregateOrderBy     `json:"deployments_aggregate,omitempty"`
	DesiredState               *OrderBy                         `json:"desiredState,omitempty"`
	FeatureFlagsAggregate      *FeatureFlagsAggregateOrderBy    `json:"featureFlags_aggregate,omitempty"`
	GithubRepository           *GithubRepositoriesOrderBy       `json:"githubRepository,omitempty"`
	GithubRepositoryID         *OrderBy                         `json:"githubRepositoryId,omitempty"`
	ID                         *OrderBy                         `json:"id,omitempty"`
	IsLocked                   *OrderBy                         `json:"isLocked,omitempty"`
	IsLockedReason             *OrderBy                         `json:"isLockedReason,omitempty"`
	MetadataFunctions          *OrderBy                         `json:"metadataFunctions,omitempty"`
	Name                       *OrderBy                         `json:"name,omitempty"`
	NhostBaseFolder            *OrderBy                         `json:"nhostBaseFolder,omitempty"`
	Plan                       *PlansOrderBy                    `json:"plan,omitempty"`
	Region                     *RegionsOrderBy                  `json:"region,omitempty"`
	RepositoryProductionBranch *OrderBy                         `json:"repositoryProductionBranch,omitempty"`
	RunServicesAggregate       *RunServiceAggregateOrderBy      `json:"runServices_aggregate,omitempty"`
	Slug                       *OrderBy                         `json:"slug,omitempty"`
	Subdomain                  *OrderBy                         `json:"subdomain,omitempty"`
	UpdatedAt                  *OrderBy                         `json:"updatedAt,omitempty"`
	Workspace                  *WorkspacesOrderBy               `json:"workspace,omitempty"`
	WorkspaceID                *OrderBy                         `json:"workspaceId,omitempty"`
}

Ordering options when selecting data from "apps".

type AppsPkColumnsInput 

type AppsPkColumnsInput struct {
	ID string `json:"id"`
}

primary key columns input for table: apps

type AppsSelectColumn 

type AppsSelectColumn string

select columns of table "apps" 

const (
	// column name
	AppsSelectColumnCreatedAt AppsSelectColumn = "createdAt"
	// column name
	AppsSelectColumnCreatorUserID AppsSelectColumn = "creatorUserId"
	// column name
	AppsSelectColumnDesiredState AppsSelectColumn = "desiredState"
	// column name
	AppsSelectColumnGithubRepositoryID AppsSelectColumn = "githubRepositoryId"
	// column name
	AppsSelectColumnID AppsSelectColumn = "id"
	// column name
	AppsSelectColumnIsLocked AppsSelectColumn = "isLocked"
	// column name
	AppsSelectColumnIsLockedReason AppsSelectColumn = "isLockedReason"
	// column name
	AppsSelectColumnMetadataFunctions AppsSelectColumn = "metadataFunctions"
	// column name
	AppsSelectColumnName AppsSelectColumn = "name"
	// column name
	AppsSelectColumnNhostBaseFolder AppsSelectColumn = "nhostBaseFolder"
	// column name
	AppsSelectColumnRepositoryProductionBranch AppsSelectColumn = "repositoryProductionBranch"
	// column name
	AppsSelectColumnSlug AppsSelectColumn = "slug"
	// column name
	AppsSelectColumnSubdomain AppsSelectColumn = "subdomain"
	// column name
	AppsSelectColumnUpdatedAt AppsSelectColumn = "updatedAt"
	// column name
	AppsSelectColumnWorkspaceID AppsSelectColumn = "workspaceId"
)

func (AppsSelectColumn) IsValid 

func (e AppsSelectColumn) IsValid() bool

func (AppsSelectColumn) MarshalGQL 

func (e AppsSelectColumn) MarshalGQL(w io.Writer)

func (AppsSelectColumn) String 

func (e AppsSelectColumn) String() string

func (*AppsSelectColumn) UnmarshalGQL 

func (e *AppsSelectColumn) UnmarshalGQL(v interface{}) error

type AppsSetInput 

type AppsSetInput struct {
	DesiredState               *int64  `json:"desiredState,omitempty"`
	GithubRepositoryID         *string `json:"githubRepositoryId,omitempty"`
	Name                       *string `json:"name,omitempty"`
	NhostBaseFolder            *string `json:"nhostBaseFolder,omitempty"`
	PlanID                     *string `json:"planId,omitempty"`
	RepositoryProductionBranch *string `json:"repositoryProductionBranch,omitempty"`
	Slug                       *string `json:"slug,omitempty"`
}

input type for updating data in table "apps"

type AppsStddevOrderBy 

type AppsStddevOrderBy struct {
	DesiredState *OrderBy `json:"desiredState,omitempty"`
}

order by stddev() on columns of table "apps"

type AppsStddevPopOrderBy 

type AppsStddevPopOrderBy struct {
	DesiredState *OrderBy `json:"desiredState,omitempty"`
}

order by stddev_pop() on columns of table "apps"

type AppsStddevSampOrderBy 

type AppsStddevSampOrderBy struct {
	DesiredState *OrderBy `json:"desiredState,omitempty"`
}

order by stddev_samp() on columns of table "apps"

type AppsStreamCursorInput 

type AppsStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *AppsStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "apps"

type AppsStreamCursorValueInput 

type AppsStreamCursorValueInput struct {
	CreatedAt                  *time.Time             `json:"createdAt,omitempty"`
	CreatorUserID              *string                `json:"creatorUserId,omitempty"`
	DesiredState               *int64                 `json:"desiredState,omitempty"`
	GithubRepositoryID         *string                `json:"githubRepositoryId,omitempty"`
	ID                         *string                `json:"id,omitempty"`
	IsLocked                   *bool                  `json:"isLocked,omitempty"`
	IsLockedReason             *string                `json:"isLockedReason,omitempty"`
	MetadataFunctions          map[string]interface{} `json:"metadataFunctions,omitempty"`
	Name                       *string                `json:"name,omitempty"`
	NhostBaseFolder            *string                `json:"nhostBaseFolder,omitempty"`
	RepositoryProductionBranch *string                `json:"repositoryProductionBranch,omitempty"`
	Slug                       *string                `json:"slug,omitempty"`
	Subdomain                  *string                `json:"subdomain,omitempty"`
	UpdatedAt                  *time.Time             `json:"updatedAt,omitempty"`
	WorkspaceID                *string                `json:"workspaceId,omitempty"`
}

Initial value of the column from where the streaming should start

type AppsSumOrderBy 

type AppsSumOrderBy struct {
	DesiredState *OrderBy `json:"desiredState,omitempty"`
}

order by sum() on columns of table "apps"

type AppsUpdateColumn 

type AppsUpdateColumn string

update columns of table "apps" 

const (
	// column name
	AppsUpdateColumnDesiredState AppsUpdateColumn = "desiredState"
	// column name
	AppsUpdateColumnGithubRepositoryID AppsUpdateColumn = "githubRepositoryId"
	// column name
	AppsUpdateColumnName AppsUpdateColumn = "name"
	// column name
	AppsUpdateColumnNhostBaseFolder AppsUpdateColumn = "nhostBaseFolder"
	// column name
	AppsUpdateColumnPlanID AppsUpdateColumn = "planId"
	// column name
	AppsUpdateColumnRepositoryProductionBranch AppsUpdateColumn = "repositoryProductionBranch"
	// column name
	AppsUpdateColumnSlug AppsUpdateColumn = "slug"
)

func (AppsUpdateColumn) IsValid 

func (e AppsUpdateColumn) IsValid() bool

func (AppsUpdateColumn) MarshalGQL 

func (e AppsUpdateColumn) MarshalGQL(w io.Writer)

func (AppsUpdateColumn) String 

func (e AppsUpdateColumn) String() string

func (*AppsUpdateColumn) UnmarshalGQL 

func (e *AppsUpdateColumn) UnmarshalGQL(v interface{}) error

type AppsUpdates 

type AppsUpdates struct {
	// increments the numeric columns with given value of the filtered values
	Inc *AppsIncInput `json:"_inc,omitempty"`
	// sets the columns of the filtered rows to the given values
	Set *AppsSetInput `json:"_set,omitempty"`
	// filter the rows which have to be updated
	Where *AppsBoolExp `json:"where"`
}

type AppsVarPopOrderBy 

type AppsVarPopOrderBy struct {
	DesiredState *OrderBy `json:"desiredState,omitempty"`
}

order by var_pop() on columns of table "apps"

type AppsVarSampOrderBy 

type AppsVarSampOrderBy struct {
	DesiredState *OrderBy `json:"desiredState,omitempty"`
}

order by var_samp() on columns of table "apps"

type AppsVarianceOrderBy 

type AppsVarianceOrderBy struct {
	DesiredState *OrderBy `json:"desiredState,omitempty"`
}

order by variance() on columns of table "apps"

type AuthRefreshTokenTypesEnum added in v1.5.0 

type AuthRefreshTokenTypesEnum string
const (
	// Personal access token
	AuthRefreshTokenTypesEnumPat AuthRefreshTokenTypesEnum = "pat"
	// Regular refresh token
	AuthRefreshTokenTypesEnumRegular AuthRefreshTokenTypesEnum = "regular"
)

func (AuthRefreshTokenTypesEnum) IsValid added in v1.5.0 

func (e AuthRefreshTokenTypesEnum) IsValid() bool

func (AuthRefreshTokenTypesEnum) MarshalGQL added in v1.5.0 

func (e AuthRefreshTokenTypesEnum) MarshalGQL(w io.Writer)

func (AuthRefreshTokenTypesEnum) String added in v1.5.0 

func (e AuthRefreshTokenTypesEnum) String() string

func (*AuthRefreshTokenTypesEnum) UnmarshalGQL added in v1.5.0 

func (e *AuthRefreshTokenTypesEnum) UnmarshalGQL(v interface{}) error

type AuthRefreshTokenTypesEnumComparisonExp added in v1.5.0 

type AuthRefreshTokenTypesEnumComparisonExp struct {
	Eq     *AuthRefreshTokenTypesEnum  `json:"_eq,omitempty"`
	In     []AuthRefreshTokenTypesEnum `json:"_in,omitempty"`
	IsNull *bool                       `json:"_is_null,omitempty"`
	Neq    *AuthRefreshTokenTypesEnum  `json:"_neq,omitempty"`
	Nin    []AuthRefreshTokenTypesEnum `json:"_nin,omitempty"`
}

Boolean expression to compare columns of type "authRefreshTokenTypes_enum". All fields are combined with logical 'AND'.

type AuthRefreshTokens 

type AuthRefreshTokens struct {
	CreatedAt time.Time                 `json:"createdAt"`
	ExpiresAt time.Time                 `json:"expiresAt"`
	ID        string                    `json:"id"`
	Metadata  map[string]interface{}    `json:"metadata,omitempty"`
	Type      AuthRefreshTokenTypesEnum `json:"type"`
	// An object relationship
	User   *Users `json:"user"`
	UserID string `json:"userId"`
}

User refresh tokens. Hasura auth uses them to rotate new access tokens as long as the refresh token is not expired. Don't modify its structure as Hasura Auth relies on it to function properly.

type AuthRefreshTokensAggregateOrderBy 

type AuthRefreshTokensAggregateOrderBy struct {
	Count *OrderBy                     `json:"count,omitempty"`
	Max   *AuthRefreshTokensMaxOrderBy `json:"max,omitempty"`
	Min   *AuthRefreshTokensMinOrderBy `json:"min,omitempty"`
}

order by aggregate values of table "auth.refresh_tokens"

type AuthRefreshTokensBoolExp 

type AuthRefreshTokensBoolExp struct {
	And       []*AuthRefreshTokensBoolExp             `json:"_and,omitempty"`
	Not       *AuthRefreshTokensBoolExp               `json:"_not,omitempty"`
	Or        []*AuthRefreshTokensBoolExp             `json:"_or,omitempty"`
	CreatedAt *TimestamptzComparisonExp               `json:"createdAt,omitempty"`
	ExpiresAt *TimestamptzComparisonExp               `json:"expiresAt,omitempty"`
	ID        *UUIDComparisonExp                      `json:"id,omitempty"`
	Metadata  *JsonbComparisonExp                     `json:"metadata,omitempty"`
	Type      *AuthRefreshTokenTypesEnumComparisonExp `json:"type,omitempty"`
	User      *UsersBoolExp                           `json:"user,omitempty"`
	UserID    *UUIDComparisonExp                      `json:"userId,omitempty"`
}

Boolean expression to filter rows from the table "auth.refresh_tokens". All fields are combined with a logical 'AND'.

type AuthRefreshTokensMaxOrderBy 

type AuthRefreshTokensMaxOrderBy struct {
	CreatedAt *OrderBy `json:"createdAt,omitempty"`
	ExpiresAt *OrderBy `json:"expiresAt,omitempty"`
	ID        *OrderBy `json:"id,omitempty"`
	UserID    *OrderBy `json:"userId,omitempty"`
}

order by max() on columns of table "auth.refresh_tokens"

type AuthRefreshTokensMinOrderBy 

type AuthRefreshTokensMinOrderBy struct {
	CreatedAt *OrderBy `json:"createdAt,omitempty"`
	ExpiresAt *OrderBy `json:"expiresAt,omitempty"`
	ID        *OrderBy `json:"id,omitempty"`
	UserID    *OrderBy `json:"userId,omitempty"`
}

order by min() on columns of table "auth.refresh_tokens"

type AuthRefreshTokensMutationResponse 

type AuthRefreshTokensMutationResponse struct {
	// number of rows affected by the mutation
	AffectedRows int64 `json:"affected_rows"`
	// data from the rows affected by the mutation
	Returning []*AuthRefreshTokens `json:"returning"`
}

response of any mutation on the table "auth.refresh_tokens"

type AuthRefreshTokensOrderBy 

type AuthRefreshTokensOrderBy struct {
	CreatedAt *OrderBy      `json:"createdAt,omitempty"`
	ExpiresAt *OrderBy      `json:"expiresAt,omitempty"`
	ID        *OrderBy      `json:"id,omitempty"`
	Metadata  *OrderBy      `json:"metadata,omitempty"`
	Type      *OrderBy      `json:"type,omitempty"`
	User      *UsersOrderBy `json:"user,omitempty"`
	UserID    *OrderBy      `json:"userId,omitempty"`
}

Ordering options when selecting data from "auth.refresh_tokens".

type AuthRefreshTokensSelectColumn 

type AuthRefreshTokensSelectColumn string

select columns of table "auth.refresh_tokens" 

const (
	// column name
	AuthRefreshTokensSelectColumnCreatedAt AuthRefreshTokensSelectColumn = "createdAt"
	// column name
	AuthRefreshTokensSelectColumnExpiresAt AuthRefreshTokensSelectColumn = "expiresAt"
	// column name
	AuthRefreshTokensSelectColumnID AuthRefreshTokensSelectColumn = "id"
	// column name
	AuthRefreshTokensSelectColumnMetadata AuthRefreshTokensSelectColumn = "metadata"
	// column name
	AuthRefreshTokensSelectColumnType AuthRefreshTokensSelectColumn = "type"
	// column name
	AuthRefreshTokensSelectColumnUserID AuthRefreshTokensSelectColumn = "userId"
)

func (AuthRefreshTokensSelectColumn) IsValid 

func (e AuthRefreshTokensSelectColumn) IsValid() bool

func (AuthRefreshTokensSelectColumn) MarshalGQL 

func (e AuthRefreshTokensSelectColumn) MarshalGQL(w io.Writer)

func (AuthRefreshTokensSelectColumn) String 

func (e AuthRefreshTokensSelectColumn) String() string

func (*AuthRefreshTokensSelectColumn) UnmarshalGQL 

func (e *AuthRefreshTokensSelectColumn) UnmarshalGQL(v interface{}) error

type AuthRefreshTokensStreamCursorInput 

type AuthRefreshTokensStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *AuthRefreshTokensStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "authRefreshTokens"

type AuthRefreshTokensStreamCursorValueInput 

type AuthRefreshTokensStreamCursorValueInput struct {
	CreatedAt *time.Time                 `json:"createdAt,omitempty"`
	ExpiresAt *time.Time                 `json:"expiresAt,omitempty"`
	ID        *string                    `json:"id,omitempty"`
	Metadata  map[string]interface{}     `json:"metadata,omitempty"`
	Type      *AuthRefreshTokenTypesEnum `json:"type,omitempty"`
	UserID    *string                    `json:"userId,omitempty"`
}

Initial value of the column from where the streaming should start

type AuthUserProviders 

type AuthUserProviders struct {
	ID         string `json:"id"`
	ProviderID string `json:"providerId"`
	// An object relationship
	User *Users `json:"user"`
}

Active providers for a given user. Don't modify its structure as Hasura Auth relies on it to function properly.

type AuthUserProvidersAggregateOrderBy 

type AuthUserProvidersAggregateOrderBy struct {
	Count *OrderBy                     `json:"count,omitempty"`
	Max   *AuthUserProvidersMaxOrderBy `json:"max,omitempty"`
	Min   *AuthUserProvidersMinOrderBy `json:"min,omitempty"`
}

order by aggregate values of table "auth.user_providers"

type AuthUserProvidersBoolExp 

type AuthUserProvidersBoolExp struct {
	And        []*AuthUserProvidersBoolExp `json:"_and,omitempty"`
	Not        *AuthUserProvidersBoolExp   `json:"_not,omitempty"`
	Or         []*AuthUserProvidersBoolExp `json:"_or,omitempty"`
	ID         *UUIDComparisonExp          `json:"id,omitempty"`
	ProviderID *StringComparisonExp        `json:"providerId,omitempty"`
	User       *UsersBoolExp               `json:"user,omitempty"`
}

Boolean expression to filter rows from the table "auth.user_providers". All fields are combined with a logical 'AND'.

type AuthUserProvidersMaxOrderBy 

type AuthUserProvidersMaxOrderBy struct {
	ID         *OrderBy `json:"id,omitempty"`
	ProviderID *OrderBy `json:"providerId,omitempty"`
}

order by max() on columns of table "auth.user_providers"

type AuthUserProvidersMinOrderBy 

type AuthUserProvidersMinOrderBy struct {
	ID         *OrderBy `json:"id,omitempty"`
	ProviderID *OrderBy `json:"providerId,omitempty"`
}

order by min() on columns of table "auth.user_providers"

type AuthUserProvidersOrderBy 

type AuthUserProvidersOrderBy struct {
	ID         *OrderBy      `json:"id,omitempty"`
	ProviderID *OrderBy      `json:"providerId,omitempty"`
	User       *UsersOrderBy `json:"user,omitempty"`
}

Ordering options when selecting data from "auth.user_providers".

type AuthUserProvidersSelectColumn 

type AuthUserProvidersSelectColumn string

select columns of table "auth.user_providers" 

const (
	// column name
	AuthUserProvidersSelectColumnID AuthUserProvidersSelectColumn = "id"
	// column name
	AuthUserProvidersSelectColumnProviderID AuthUserProvidersSelectColumn = "providerId"
)

func (AuthUserProvidersSelectColumn) IsValid 

func (e AuthUserProvidersSelectColumn) IsValid() bool

func (AuthUserProvidersSelectColumn) MarshalGQL 

func (e AuthUserProvidersSelectColumn) MarshalGQL(w io.Writer)

func (AuthUserProvidersSelectColumn) String 

func (e AuthUserProvidersSelectColumn) String() string

func (*AuthUserProvidersSelectColumn) UnmarshalGQL 

func (e *AuthUserProvidersSelectColumn) UnmarshalGQL(v interface{}) error

type AuthUserProvidersStreamCursorInput 

type AuthUserProvidersStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *AuthUserProvidersStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "authUserProviders"

type AuthUserProvidersStreamCursorValueInput 

type AuthUserProvidersStreamCursorValueInput struct {
	ID         *string `json:"id,omitempty"`
	ProviderID *string `json:"providerId,omitempty"`
}

Initial value of the column from where the streaming should start

type BackupPresignedURL added in v1.5.0 

type BackupPresignedURL struct {
	ExpiresAt string `json:"expires_at"`
	URL       string `json:"url"`
}

type BackupResult 

type BackupResult struct {
	BackupID string `json:"backupID"`
	Size     int64  `json:"size"`
}

type Backups 

type Backups struct {
	// An object relationship
	App         *Apps      `json:"app"`
	AppID       string     `json:"appId"`
	CompletedAt *time.Time `json:"completedAt,omitempty"`
	CreatedAt   time.Time  `json:"createdAt"`
	ID          string     `json:"id"`
	Size        int64      `json:"size"`
}

columns and relationships of "backups"

type BackupsAggregateOrderBy 

type BackupsAggregateOrderBy struct {
	Avg        *BackupsAvgOrderBy        `json:"avg,omitempty"`
	Count      *OrderBy                  `json:"count,omitempty"`
	Max        *BackupsMaxOrderBy        `json:"max,omitempty"`
	Min        *BackupsMinOrderBy        `json:"min,omitempty"`
	Stddev     *BackupsStddevOrderBy     `json:"stddev,omitempty"`
	StddevPop  *BackupsStddevPopOrderBy  `json:"stddev_pop,omitempty"`
	StddevSamp *BackupsStddevSampOrderBy `json:"stddev_samp,omitempty"`
	Sum        *BackupsSumOrderBy        `json:"sum,omitempty"`
	VarPop     *BackupsVarPopOrderBy     `json:"var_pop,omitempty"`
	VarSamp    *BackupsVarSampOrderBy    `json:"var_samp,omitempty"`
	Variance   *BackupsVarianceOrderBy   `json:"variance,omitempty"`
}

order by aggregate values of table "backups"

type BackupsAvgOrderBy 

type BackupsAvgOrderBy struct {
	Size *OrderBy `json:"size,omitempty"`
}

order by avg() on columns of table "backups"

type BackupsBoolExp 

type BackupsBoolExp struct {
	And         []*BackupsBoolExp         `json:"_and,omitempty"`
	Not         *BackupsBoolExp           `json:"_not,omitempty"`
	Or          []*BackupsBoolExp         `json:"_or,omitempty"`
	App         *AppsBoolExp              `json:"app,omitempty"`
	AppID       *UUIDComparisonExp        `json:"appId,omitempty"`
	CompletedAt *TimestamptzComparisonExp `json:"completedAt,omitempty"`
	CreatedAt   *TimestamptzComparisonExp `json:"createdAt,omitempty"`
	ID          *UUIDComparisonExp        `json:"id,omitempty"`
	Size        *BigintComparisonExp      `json:"size,omitempty"`
}

Boolean expression to filter rows from the table "backups". All fields are combined with a logical 'AND'.

type BackupsMaxOrderBy 

type BackupsMaxOrderBy struct {
	AppID       *OrderBy `json:"appId,omitempty"`
	CompletedAt *OrderBy `json:"completedAt,omitempty"`
	CreatedAt   *OrderBy `json:"createdAt,omitempty"`
	ID          *OrderBy `json:"id,omitempty"`
	Size        *OrderBy `json:"size,omitempty"`
}

order by max() on columns of table "backups"

type BackupsMinOrderBy 

type BackupsMinOrderBy struct {
	AppID       *OrderBy `json:"appId,omitempty"`
	CompletedAt *OrderBy `json:"completedAt,omitempty"`
	CreatedAt   *OrderBy `json:"createdAt,omitempty"`
	ID          *OrderBy `json:"id,omitempty"`
	Size        *OrderBy `json:"size,omitempty"`
}

order by min() on columns of table "backups"

type BackupsOrderBy 

type BackupsOrderBy struct {
	App         *AppsOrderBy `json:"app,omitempty"`
	AppID       *OrderBy     `json:"appId,omitempty"`
	CompletedAt *OrderBy     `json:"completedAt,omitempty"`
	CreatedAt   *OrderBy     `json:"createdAt,omitempty"`
	ID          *OrderBy     `json:"id,omitempty"`
	Size        *OrderBy     `json:"size,omitempty"`
}

Ordering options when selecting data from "backups".

type BackupsSelectColumn 

type BackupsSelectColumn string

select columns of table "backups" 

const (
	// column name
	BackupsSelectColumnAppID BackupsSelectColumn = "appId"
	// column name
	BackupsSelectColumnCompletedAt BackupsSelectColumn = "completedAt"
	// column name
	BackupsSelectColumnCreatedAt BackupsSelectColumn = "createdAt"
	// column name
	BackupsSelectColumnID BackupsSelectColumn = "id"
	// column name
	BackupsSelectColumnSize BackupsSelectColumn = "size"
)

func (BackupsSelectColumn) IsValid 

func (e BackupsSelectColumn) IsValid() bool

func (BackupsSelectColumn) MarshalGQL 

func (e BackupsSelectColumn) MarshalGQL(w io.Writer)

func (BackupsSelectColumn) String 

func (e BackupsSelectColumn) String() string

func (*BackupsSelectColumn) UnmarshalGQL 

func (e *BackupsSelectColumn) UnmarshalGQL(v interface{}) error

type BackupsStddevOrderBy 

type BackupsStddevOrderBy struct {
	Size *OrderBy `json:"size,omitempty"`
}

order by stddev() on columns of table "backups"

type BackupsStddevPopOrderBy 

type BackupsStddevPopOrderBy struct {
	Size *OrderBy `json:"size,omitempty"`
}

order by stddev_pop() on columns of table "backups"

type BackupsStddevSampOrderBy 

type BackupsStddevSampOrderBy struct {
	Size *OrderBy `json:"size,omitempty"`
}

order by stddev_samp() on columns of table "backups"

type BackupsStreamCursorInput 

type BackupsStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *BackupsStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "backups"

type BackupsStreamCursorValueInput 

type BackupsStreamCursorValueInput struct {
	AppID       *string    `json:"appId,omitempty"`
	CompletedAt *time.Time `json:"completedAt,omitempty"`
	CreatedAt   *time.Time `json:"createdAt,omitempty"`
	ID          *string    `json:"id,omitempty"`
	Size        *int64     `json:"size,omitempty"`
}

Initial value of the column from where the streaming should start

type BackupsSumOrderBy 

type BackupsSumOrderBy struct {
	Size *OrderBy `json:"size,omitempty"`
}

order by sum() on columns of table "backups"

type BackupsVarPopOrderBy 

type BackupsVarPopOrderBy struct {
	Size *OrderBy `json:"size,omitempty"`
}

order by var_pop() on columns of table "backups"

type BackupsVarSampOrderBy 

type BackupsVarSampOrderBy struct {
	Size *OrderBy `json:"size,omitempty"`
}

order by var_samp() on columns of table "backups"

type BackupsVarianceOrderBy 

type BackupsVarianceOrderBy struct {
	Size *OrderBy `json:"size,omitempty"`
}

order by variance() on columns of table "backups"

type BigintComparisonExp 

type BigintComparisonExp struct {
	Eq     *int64  `json:"_eq,omitempty"`
	Gt     *int64  `json:"_gt,omitempty"`
	Gte    *int64  `json:"_gte,omitempty"`
	In     []int64 `json:"_in,omitempty"`
	IsNull *bool   `json:"_is_null,omitempty"`
	Lt     *int64  `json:"_lt,omitempty"`
	Lte    *int64  `json:"_lte,omitempty"`
	Neq    *int64  `json:"_neq,omitempty"`
	Nin    []int64 `json:"_nin,omitempty"`
}

Boolean expression to compare columns of type "bigint". All fields are combined with logical 'AND'.

type BooleanComparisonExp 

type BooleanComparisonExp struct {
	Eq     *bool  `json:"_eq,omitempty"`
	Gt     *bool  `json:"_gt,omitempty"`
	Gte    *bool  `json:"_gte,omitempty"`
	In     []bool `json:"_in,omitempty"`
	IsNull *bool  `json:"_is_null,omitempty"`
	Lt     *bool  `json:"_lt,omitempty"`
	Lte    *bool  `json:"_lte,omitempty"`
	Neq    *bool  `json:"_neq,omitempty"`
	Nin    []bool `json:"_nin,omitempty"`
}

Boolean expression to compare columns of type "Boolean". All fields are combined with logical 'AND'.

type BpcharComparisonExp 

type BpcharComparisonExp struct {
	Eq  *string `json:"_eq,omitempty"`
	Gt  *string `json:"_gt,omitempty"`
	Gte *string `json:"_gte,omitempty"`
	// does the column match the given case-insensitive pattern
	Ilike *string  `json:"_ilike,omitempty"`
	In    []string `json:"_in,omitempty"`
	// does the column match the given POSIX regular expression, case insensitive
	Iregex *string `json:"_iregex,omitempty"`
	IsNull *bool   `json:"_is_null,omitempty"`
	// does the column match the given pattern
	Like *string `json:"_like,omitempty"`
	Lt   *string `json:"_lt,omitempty"`
	Lte  *string `json:"_lte,omitempty"`
	Neq  *string `json:"_neq,omitempty"`
	// does the column NOT match the given case-insensitive pattern
	Nilike *string  `json:"_nilike,omitempty"`
	Nin    []string `json:"_nin,omitempty"`
	// does the column NOT match the given POSIX regular expression, case insensitive
	Niregex *string `json:"_niregex,omitempty"`
	// does the column NOT match the given pattern
	Nlike *string `json:"_nlike,omitempty"`
	// does the column NOT match the given POSIX regular expression, case sensitive
	Nregex *string `json:"_nregex,omitempty"`
	// does the column NOT match the given SQL regular expression
	Nsimilar *string `json:"_nsimilar,omitempty"`
	// does the column match the given POSIX regular expression, case sensitive
	Regex *string `json:"_regex,omitempty"`
	// does the column match the given SQL regular expression
	Similar *string `json:"_similar,omitempty"`
}

Boolean expression to compare columns of type "bpchar". All fields are combined with logical 'AND'.

type CitextComparisonExp 

type CitextComparisonExp struct {
	Eq  *string `json:"_eq,omitempty"`
	Gt  *string `json:"_gt,omitempty"`
	Gte *string `json:"_gte,omitempty"`
	// does the column match the given case-insensitive pattern
	Ilike *string  `json:"_ilike,omitempty"`
	In    []string `json:"_in,omitempty"`
	// does the column match the given POSIX regular expression, case insensitive
	Iregex *string `json:"_iregex,omitempty"`
	IsNull *bool   `json:"_is_null,omitempty"`
	// does the column match the given pattern
	Like *string `json:"_like,omitempty"`
	Lt   *string `json:"_lt,omitempty"`
	Lte  *string `json:"_lte,omitempty"`
	Neq  *string `json:"_neq,omitempty"`
	// does the column NOT match the given case-insensitive pattern
	Nilike *string  `json:"_nilike,omitempty"`
	Nin    []string `json:"_nin,omitempty"`
	// does the column NOT match the given POSIX regular expression, case insensitive
	Niregex *string `json:"_niregex,omitempty"`
	// does the column NOT match the given pattern
	Nlike *string `json:"_nlike,omitempty"`
	// does the column NOT match the given POSIX regular expression, case sensitive
	Nregex *string `json:"_nregex,omitempty"`
	// does the column NOT match the given SQL regular expression
	Nsimilar *string `json:"_nsimilar,omitempty"`
	// does the column match the given POSIX regular expression, case sensitive
	Regex *string `json:"_regex,omitempty"`
	// does the column match the given SQL regular expression
	Similar *string `json:"_similar,omitempty"`
}

Boolean expression to compare columns of type "citext". All fields are combined with logical 'AND'.

type CliTokens 

type CliTokens struct {
	CreatedAt time.Time `json:"createdAt"`
	ID        string    `json:"id"`
	UpdatedAt time.Time `json:"updatedAt"`
	// An object relationship
	User *Users `json:"user"`
}

columns and relationships of "cli_tokens"

type CliTokensAggregateOrderBy 

type CliTokensAggregateOrderBy struct {
	Count *OrderBy             `json:"count,omitempty"`
	Max   *CliTokensMaxOrderBy `json:"max,omitempty"`
	Min   *CliTokensMinOrderBy `json:"min,omitempty"`
}

order by aggregate values of table "cli_tokens"

type CliTokensBoolExp 

type CliTokensBoolExp struct {
	And       []*CliTokensBoolExp       `json:"_and,omitempty"`
	Not       *CliTokensBoolExp         `json:"_not,omitempty"`
	Or        []*CliTokensBoolExp       `json:"_or,omitempty"`
	CreatedAt *TimestamptzComparisonExp `json:"createdAt,omitempty"`
	ID        *UUIDComparisonExp        `json:"id,omitempty"`
	UpdatedAt *TimestamptzComparisonExp `json:"updatedAt,omitempty"`
	User      *UsersBoolExp             `json:"user,omitempty"`
}

Boolean expression to filter rows from the table "cli_tokens". All fields are combined with a logical 'AND'.

type CliTokensMaxOrderBy 

type CliTokensMaxOrderBy struct {
	CreatedAt *OrderBy `json:"createdAt,omitempty"`
	ID        *OrderBy `json:"id,omitempty"`
	UpdatedAt *OrderBy `json:"updatedAt,omitempty"`
}

order by max() on columns of table "cli_tokens"

type CliTokensMinOrderBy 

type CliTokensMinOrderBy struct {
	CreatedAt *OrderBy `json:"createdAt,omitempty"`
	ID        *OrderBy `json:"id,omitempty"`
	UpdatedAt *OrderBy `json:"updatedAt,omitempty"`
}

order by min() on columns of table "cli_tokens"

type CliTokensMutationResponse 

type CliTokensMutationResponse struct {
	// number of rows affected by the mutation
	AffectedRows int64 `json:"affected_rows"`
	// data from the rows affected by the mutation
	Returning []*CliTokens `json:"returning"`
}

response of any mutation on the table "cli_tokens"

type CliTokensOrderBy 

type CliTokensOrderBy struct {
	CreatedAt *OrderBy      `json:"createdAt,omitempty"`
	ID        *OrderBy      `json:"id,omitempty"`
	UpdatedAt *OrderBy      `json:"updatedAt,omitempty"`
	User      *UsersOrderBy `json:"user,omitempty"`
}

Ordering options when selecting data from "cli_tokens".

type CliTokensSelectColumn 

type CliTokensSelectColumn string

select columns of table "cli_tokens" 

const (
	// column name
	CliTokensSelectColumnCreatedAt CliTokensSelectColumn = "createdAt"
	// column name
	CliTokensSelectColumnID CliTokensSelectColumn = "id"
	// column name
	CliTokensSelectColumnUpdatedAt CliTokensSelectColumn = "updatedAt"
)

func (CliTokensSelectColumn) IsValid 

func (e CliTokensSelectColumn) IsValid() bool

func (CliTokensSelectColumn) MarshalGQL 

func (e CliTokensSelectColumn) MarshalGQL(w io.Writer)

func (CliTokensSelectColumn) String 

func (e CliTokensSelectColumn) String() string

func (*CliTokensSelectColumn) UnmarshalGQL 

func (e *CliTokensSelectColumn) UnmarshalGQL(v interface{}) error

type CliTokensStreamCursorInput 

type CliTokensStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *CliTokensStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "cliTokens"

type CliTokensStreamCursorValueInput 

type CliTokensStreamCursorValueInput struct {
	CreatedAt *time.Time `json:"createdAt,omitempty"`
	ID        *string    `json:"id,omitempty"`
	UpdatedAt *time.Time `json:"updatedAt,omitempty"`
}

Initial value of the column from where the streaming should start

type Client 

type Client struct {
	Client *clientv2.Client
}

func NewClient 

func NewClient(cli *http.Client, baseURL string, options *clientv2.Options, interceptors ...clientv2.RequestInterceptor) *Client

func (*Client) CreateSecret 

func (c *Client) CreateSecret(ctx context.Context, appID string, name string, value string, interceptors ...clientv2.RequestInterceptor) (*CreateSecret, error)

func (*Client) DeleteRefreshToken 

func (c *Client) DeleteRefreshToken(ctx context.Context, where AuthRefreshTokensBoolExp, interceptors ...clientv2.RequestInterceptor) (*DeleteRefreshToken, error)

func (*Client) DeleteSecret 

func (c *Client) DeleteSecret(ctx context.Context, appID string, name string, interceptors ...clientv2.RequestInterceptor) (*DeleteSecret, error)

func (*Client) GetConfigRawJSON 

func (c *Client) GetConfigRawJSON(ctx context.Context, appID string, interceptors ...clientv2.RequestInterceptor) (*GetConfigRawJSON, error)

func (*Client) GetHasuraAdminSecret 

func (c *Client) GetHasuraAdminSecret(ctx context.Context, appID string, interceptors ...clientv2.RequestInterceptor) (*GetHasuraAdminSecret, error)

func (*Client) GetRunServiceConfigRawJSON added in v1.5.0 

func (c *Client) GetRunServiceConfigRawJSON(ctx context.Context, appID string, serviceID string, resolve bool, interceptors ...clientv2.RequestInterceptor) (*GetRunServiceConfigRawJSON, error)

func (*Client) GetRunServiceInfo added in v1.5.0 

func (c *Client) GetRunServiceInfo(ctx context.Context, serviceID string, interceptors ...clientv2.RequestInterceptor) (*GetRunServiceInfo, error)

func (*Client) GetSecrets 

func (c *Client) GetSecrets(ctx context.Context, appID string, interceptors ...clientv2.RequestInterceptor) (*GetSecrets, error)

func (*Client) GetSoftwareVersions added in v1.17.0 

func (c *Client) GetSoftwareVersions(ctx context.Context, interceptors ...clientv2.RequestInterceptor) (*GetSoftwareVersions, error)

func (*Client) GetWorkspacesApps 

func (c *Client) GetWorkspacesApps(ctx context.Context, interceptors ...clientv2.RequestInterceptor) (*GetWorkspacesApps, error)

func (*Client) ReplaceRunServiceConfig added in v1.5.0 

func (c *Client) ReplaceRunServiceConfig(ctx context.Context, appID string, serviceID string, config ConfigRunServiceConfigInsertInput, interceptors ...clientv2.RequestInterceptor) (*ReplaceRunServiceConfig, error)

func (*Client) UpdateRunServiceConfig added in v1.5.0 

func (c *Client) UpdateRunServiceConfig(ctx context.Context, appID string, serviceID string, config ConfigRunServiceConfigUpdateInput, interceptors ...clientv2.RequestInterceptor) (*UpdateRunServiceConfig, error)

func (*Client) UpdateSecret 

func (c *Client) UpdateSecret(ctx context.Context, appID string, name string, value string, interceptors ...clientv2.RequestInterceptor) (*UpdateSecret, error)

type ConfigAIAutoEmbeddings added in v1.10.0 

type ConfigAIAutoEmbeddings struct {
	SynchPeriodMinutes *uint32 `json:"synchPeriodMinutes,omitempty"`
}

type ConfigAIAutoEmbeddingsUpdateInput added in v1.10.0 

type ConfigAIAutoEmbeddingsUpdateInput struct {
	SynchPeriodMinutes *uint32 `json:"synchPeriodMinutes,omitempty"`
}

type ConfigAIOpenai added in v1.10.0 

type ConfigAIOpenai struct {
	APIKey       string  `json:"apiKey"`
	Organization *string `json:"organization,omitempty"`
}

type ConfigAIOpenaiUpdateInput added in v1.10.0 

type ConfigAIOpenaiUpdateInput struct {
	APIKey       *string `json:"apiKey,omitempty"`
	Organization *string `json:"organization,omitempty"`
}

type ConfigAIResources added in v1.10.0 

type ConfigAIResources struct {
	Compute *ConfigComputeResources `json:"compute"`
}

type ConfigAIResourcesUpdateInput added in v1.10.0 

type ConfigAIResourcesUpdateInput struct {
	Compute *ConfigComputeResourcesUpdateInput `json:"compute,omitempty"`
}

type ConfigAIUpdateInput added in v1.10.0 

type ConfigAIUpdateInput struct {
	AutoEmbeddings *ConfigAIAutoEmbeddingsUpdateInput `json:"autoEmbeddings,omitempty"`
	Openai         *ConfigAIOpenaiUpdateInput         `json:"openai,omitempty"`
	Resources      *ConfigAIResourcesUpdateInput      `json:"resources,omitempty"`
	Version        *string                            `json:"version,omitempty"`
	WebhookSecret  *string                            `json:"webhookSecret,omitempty"`
}

type ConfigAi added in v1.10.0 

type ConfigAi struct {
	AutoEmbeddings *ConfigAIAutoEmbeddings `json:"autoEmbeddings,omitempty"`
	Openai         *ConfigAIOpenai         `json:"openai"`
	Resources      *ConfigAIResources      `json:"resources"`
	Version        *string                 `json:"version,omitempty"`
	WebhookSecret  string                  `json:"webhookSecret"`
}

type ConfigAuth 

type ConfigAuth struct {
	ElevatedPrivileges *ConfigAuthElevatedPrivileges `json:"elevatedPrivileges,omitempty"`
	Method             *ConfigAuthMethod             `json:"method,omitempty"`
	Redirections       *ConfigAuthRedirections       `json:"redirections,omitempty"`
	Resources          *ConfigResources              `json:"resources,omitempty"`
	Session            *ConfigAuthSession            `json:"session,omitempty"`
	SignUp             *ConfigAuthSignUp             `json:"signUp,omitempty"`
	Totp               *ConfigAuthTotp               `json:"totp,omitempty"`
	User               *ConfigAuthUser               `json:"user,omitempty"`
	Version            *string                       `json:"version,omitempty"`
}

type ConfigAuthElevatedPrivileges added in v1.14.0 

type ConfigAuthElevatedPrivileges struct {
	Mode *string `json:"mode,omitempty"`
}

type ConfigAuthElevatedPrivilegesUpdateInput added in v1.14.0 

type ConfigAuthElevatedPrivilegesUpdateInput struct {
	Mode *string `json:"mode,omitempty"`
}

type ConfigAuthMethod 

type ConfigAuthMethod struct {
	Anonymous         *ConfigAuthMethodAnonymous         `json:"anonymous,omitempty"`
	EmailPassword     *ConfigAuthMethodEmailPassword     `json:"emailPassword,omitempty"`
	EmailPasswordless *ConfigAuthMethodEmailPasswordless `json:"emailPasswordless,omitempty"`
	Oauth             *ConfigAuthMethodOauth             `json:"oauth,omitempty"`
	SmsPasswordless   *ConfigAuthMethodSmsPasswordless   `json:"smsPasswordless,omitempty"`
	Webauthn          *ConfigAuthMethodWebauthn          `json:"webauthn,omitempty"`
}

type ConfigAuthMethodAnonymous 

type ConfigAuthMethodAnonymous struct {
	Enabled *bool `json:"enabled,omitempty"`
}

type ConfigAuthMethodAnonymousUpdateInput 

type ConfigAuthMethodAnonymousUpdateInput struct {
	Enabled *bool `json:"enabled,omitempty"`
}

type ConfigAuthMethodEmailPassword 

type ConfigAuthMethodEmailPassword struct {
	EmailVerificationRequired *bool   `json:"emailVerificationRequired,omitempty"`
	HibpEnabled               *bool   `json:"hibpEnabled,omitempty"`
	PasswordMinLength         *uint32 `json:"passwordMinLength,omitempty"`
}

type ConfigAuthMethodEmailPasswordUpdateInput 

type ConfigAuthMethodEmailPasswordUpdateInput struct {
	EmailVerificationRequired *bool   `json:"emailVerificationRequired,omitempty"`
	HibpEnabled               *bool   `json:"hibpEnabled,omitempty"`
	PasswordMinLength         *uint32 `json:"passwordMinLength,omitempty"`
}

type ConfigAuthMethodEmailPasswordless 

type ConfigAuthMethodEmailPasswordless struct {
	Enabled *bool `json:"enabled,omitempty"`
}

type ConfigAuthMethodEmailPasswordlessUpdateInput 

type ConfigAuthMethodEmailPasswordlessUpdateInput struct {
	Enabled *bool `json:"enabled,omitempty"`
}

type ConfigAuthMethodOauth 

type ConfigAuthMethodOauth struct {
	Apple       *ConfigAuthMethodOauthApple           `json:"apple,omitempty"`
	Azuread     *ConfigAuthMethodOauthAzuread         `json:"azuread,omitempty"`
	Bitbucket   *ConfigStandardOauthProvider          `json:"bitbucket,omitempty"`
	Discord     *ConfigStandardOauthProviderWithScope `json:"discord,omitempty"`
	Facebook    *ConfigStandardOauthProviderWithScope `json:"facebook,omitempty"`
	Github      *ConfigStandardOauthProviderWithScope `json:"github,omitempty"`
	Gitlab      *ConfigStandardOauthProviderWithScope `json:"gitlab,omitempty"`
	Google      *ConfigStandardOauthProviderWithScope `json:"google,omitempty"`
	Linkedin    *ConfigStandardOauthProviderWithScope `json:"linkedin,omitempty"`
	Spotify     *ConfigStandardOauthProviderWithScope `json:"spotify,omitempty"`
	Strava      *ConfigStandardOauthProviderWithScope `json:"strava,omitempty"`
	Twitch      *ConfigStandardOauthProviderWithScope `json:"twitch,omitempty"`
	Twitter     *ConfigAuthMethodOauthTwitter         `json:"twitter,omitempty"`
	Windowslive *ConfigStandardOauthProviderWithScope `json:"windowslive,omitempty"`
	Workos      *ConfigAuthMethodOauthWorkos          `json:"workos,omitempty"`
}

type ConfigAuthMethodOauthApple 

type ConfigAuthMethodOauthApple struct {
	ClientID   *string  `json:"clientId,omitempty"`
	Enabled    *bool    `json:"enabled,omitempty"`
	KeyID      *string  `json:"keyId,omitempty"`
	PrivateKey *string  `json:"privateKey,omitempty"`
	Scope      []string `json:"scope,omitempty"`
	TeamID     *string  `json:"teamId,omitempty"`
}

type ConfigAuthMethodOauthAppleUpdateInput 

type ConfigAuthMethodOauthAppleUpdateInput struct {
	ClientID   *string  `json:"clientId,omitempty"`
	Enabled    *bool    `json:"enabled,omitempty"`
	KeyID      *string  `json:"keyId,omitempty"`
	PrivateKey *string  `json:"privateKey,omitempty"`
	Scope      []string `json:"scope,omitempty"`
	TeamID     *string  `json:"teamId,omitempty"`
}

type ConfigAuthMethodOauthAzuread 

type ConfigAuthMethodOauthAzuread struct {
	ClientID     *string `json:"clientId,omitempty"`
	ClientSecret *string `json:"clientSecret,omitempty"`
	Enabled      *bool   `json:"enabled,omitempty"`
	Tenant       *string `json:"tenant,omitempty"`
}

type ConfigAuthMethodOauthAzureadUpdateInput 

type ConfigAuthMethodOauthAzureadUpdateInput struct {
	ClientID     *string `json:"clientId,omitempty"`
	ClientSecret *string `json:"clientSecret,omitempty"`
	Enabled      *bool   `json:"enabled,omitempty"`
	Tenant       *string `json:"tenant,omitempty"`
}

type ConfigAuthMethodOauthTwitter 

type ConfigAuthMethodOauthTwitter struct {
	ConsumerKey    *string `json:"consumerKey,omitempty"`
	ConsumerSecret *string `json:"consumerSecret,omitempty"`
	Enabled        *bool   `json:"enabled,omitempty"`
}

type ConfigAuthMethodOauthTwitterUpdateInput 

type ConfigAuthMethodOauthTwitterUpdateInput struct {
	ConsumerKey    *string `json:"consumerKey,omitempty"`
	ConsumerSecret *string `json:"consumerSecret,omitempty"`
	Enabled        *bool   `json:"enabled,omitempty"`
}

type ConfigAuthMethodOauthUpdateInput 

type ConfigAuthMethodOauthUpdateInput struct {
	Apple       *ConfigAuthMethodOauthAppleUpdateInput           `json:"apple,omitempty"`
	Azuread     *ConfigAuthMethodOauthAzureadUpdateInput         `json:"azuread,omitempty"`
	Bitbucket   *ConfigStandardOauthProviderUpdateInput          `json:"bitbucket,omitempty"`
	Discord     *ConfigStandardOauthProviderWithScopeUpdateInput `json:"discord,omitempty"`
	Facebook    *ConfigStandardOauthProviderWithScopeUpdateInput `json:"facebook,omitempty"`
	Github      *ConfigStandardOauthProviderWithScopeUpdateInput `json:"github,omitempty"`
	Gitlab      *ConfigStandardOauthProviderWithScopeUpdateInput `json:"gitlab,omitempty"`
	Google      *ConfigStandardOauthProviderWithScopeUpdateInput `json:"google,omitempty"`
	Linkedin    *ConfigStandardOauthProviderWithScopeUpdateInput `json:"linkedin,omitempty"`
	Spotify     *ConfigStandardOauthProviderWithScopeUpdateInput `json:"spotify,omitempty"`
	Strava      *ConfigStandardOauthProviderWithScopeUpdateInput `json:"strava,omitempty"`
	Twitch      *ConfigStandardOauthProviderWithScopeUpdateInput `json:"twitch,omitempty"`
	Twitter     *ConfigAuthMethodOauthTwitterUpdateInput         `json:"twitter,omitempty"`
	Windowslive *ConfigStandardOauthProviderWithScopeUpdateInput `json:"windowslive,omitempty"`
	Workos      *ConfigAuthMethodOauthWorkosUpdateInput          `json:"workos,omitempty"`
}

type ConfigAuthMethodOauthWorkos 

type ConfigAuthMethodOauthWorkos struct {
	ClientID     *string `json:"clientId,omitempty"`
	ClientSecret *string `json:"clientSecret,omitempty"`
	Connection   *string `json:"connection,omitempty"`
	Enabled      *bool   `json:"enabled,omitempty"`
	Organization *string `json:"organization,omitempty"`
}

type ConfigAuthMethodOauthWorkosUpdateInput 

type ConfigAuthMethodOauthWorkosUpdateInput struct {
	ClientID     *string `json:"clientId,omitempty"`
	ClientSecret *string `json:"clientSecret,omitempty"`
	Connection   *string `json:"connection,omitempty"`
	Enabled      *bool   `json:"enabled,omitempty"`
	Organization *string `json:"organization,omitempty"`
}

type ConfigAuthMethodSmsPasswordless 

type ConfigAuthMethodSmsPasswordless struct {
	Enabled *bool `json:"enabled,omitempty"`
}

type ConfigAuthMethodSmsPasswordlessUpdateInput 

type ConfigAuthMethodSmsPasswordlessUpdateInput struct {
	Enabled *bool `json:"enabled,omitempty"`
}

type ConfigAuthMethodUpdateInput 

type ConfigAuthMethodUpdateInput struct {
	Anonymous         *ConfigAuthMethodAnonymousUpdateInput         `json:"anonymous,omitempty"`
	EmailPassword     *ConfigAuthMethodEmailPasswordUpdateInput     `json:"emailPassword,omitempty"`
	EmailPasswordless *ConfigAuthMethodEmailPasswordlessUpdateInput `json:"emailPasswordless,omitempty"`
	Oauth             *ConfigAuthMethodOauthUpdateInput             `json:"oauth,omitempty"`
	SmsPasswordless   *ConfigAuthMethodSmsPasswordlessUpdateInput   `json:"smsPasswordless,omitempty"`
	Webauthn          *ConfigAuthMethodWebauthnUpdateInput          `json:"webauthn,omitempty"`
}

type ConfigAuthMethodWebauthn 

type ConfigAuthMethodWebauthn struct {
	Attestation  *ConfigAuthMethodWebauthnAttestation  `json:"attestation,omitempty"`
	Enabled      *bool                                 `json:"enabled,omitempty"`
	RelyingParty *ConfigAuthMethodWebauthnRelyingParty `json:"relyingParty,omitempty"`
}

type ConfigAuthMethodWebauthnAttestation 

type ConfigAuthMethodWebauthnAttestation struct {
	Timeout *uint32 `json:"timeout,omitempty"`
}

type ConfigAuthMethodWebauthnAttestationUpdateInput 

type ConfigAuthMethodWebauthnAttestationUpdateInput struct {
	Timeout *uint32 `json:"timeout,omitempty"`
}

type ConfigAuthMethodWebauthnRelyingParty 

type ConfigAuthMethodWebauthnRelyingParty struct {
	ID      *string  `json:"id,omitempty"`
	Name    *string  `json:"name,omitempty"`
	Origins []string `json:"origins,omitempty"`
}

type ConfigAuthMethodWebauthnRelyingPartyUpdateInput 

type ConfigAuthMethodWebauthnRelyingPartyUpdateInput struct {
	ID      *string  `json:"id,omitempty"`
	Name    *string  `json:"name,omitempty"`
	Origins []string `json:"origins,omitempty"`
}

type ConfigAuthMethodWebauthnUpdateInput 

type ConfigAuthMethodWebauthnUpdateInput struct {
	Attestation  *ConfigAuthMethodWebauthnAttestationUpdateInput  `json:"attestation,omitempty"`
	Enabled      *bool                                            `json:"enabled,omitempty"`
	RelyingParty *ConfigAuthMethodWebauthnRelyingPartyUpdateInput `json:"relyingParty,omitempty"`
}

type ConfigAuthRedirections 

type ConfigAuthRedirections struct {
	AllowedUrls []string `json:"allowedUrls,omitempty"`
	ClientURL   *string  `json:"clientUrl,omitempty"`
}

type ConfigAuthRedirectionsUpdateInput 

type ConfigAuthRedirectionsUpdateInput struct {
	AllowedUrls []string `json:"allowedUrls,omitempty"`
	ClientURL   *string  `json:"clientUrl,omitempty"`
}

type ConfigAuthSession 

type ConfigAuthSession struct {
	AccessToken  *ConfigAuthSessionAccessToken  `json:"accessToken,omitempty"`
	RefreshToken *ConfigAuthSessionRefreshToken `json:"refreshToken,omitempty"`
}

type ConfigAuthSessionAccessToken 

type ConfigAuthSessionAccessToken struct {
	CustomClaims []*ConfigAuthsessionaccessTokenCustomClaims `json:"customClaims,omitempty"`
	ExpiresIn    *uint32                                     `json:"expiresIn,omitempty"`
}

type ConfigAuthSessionAccessTokenUpdateInput 

type ConfigAuthSessionAccessTokenUpdateInput struct {
	CustomClaims []*ConfigAuthsessionaccessTokenCustomClaimsUpdateInput `json:"customClaims,omitempty"`
	ExpiresIn    *uint32                                                `json:"expiresIn,omitempty"`
}

type ConfigAuthSessionRefreshToken 

type ConfigAuthSessionRefreshToken struct {
	ExpiresIn *uint32 `json:"expiresIn,omitempty"`
}

type ConfigAuthSessionRefreshTokenUpdateInput 

type ConfigAuthSessionRefreshTokenUpdateInput struct {
	ExpiresIn *uint32 `json:"expiresIn,omitempty"`
}

type ConfigAuthSessionUpdateInput 

type ConfigAuthSessionUpdateInput struct {
	AccessToken  *ConfigAuthSessionAccessTokenUpdateInput  `json:"accessToken,omitempty"`
	RefreshToken *ConfigAuthSessionRefreshTokenUpdateInput `json:"refreshToken,omitempty"`
}

type ConfigAuthSignUp 

type ConfigAuthSignUp struct {
	DisableNewUsers *bool `json:"disableNewUsers,omitempty"`
	Enabled         *bool `json:"enabled,omitempty"`
}

type ConfigAuthSignUpUpdateInput 

type ConfigAuthSignUpUpdateInput struct {
	DisableNewUsers *bool `json:"disableNewUsers,omitempty"`
	Enabled         *bool `json:"enabled,omitempty"`
}

type ConfigAuthTotp 

type ConfigAuthTotp struct {
	Enabled *bool   `json:"enabled,omitempty"`
	Issuer  *string `json:"issuer,omitempty"`
}

type ConfigAuthTotpUpdateInput 

type ConfigAuthTotpUpdateInput struct {
	Enabled *bool   `json:"enabled,omitempty"`
	Issuer  *string `json:"issuer,omitempty"`
}

type ConfigAuthUpdateInput 

type ConfigAuthUpdateInput struct {
	ElevatedPrivileges *ConfigAuthElevatedPrivilegesUpdateInput `json:"elevatedPrivileges,omitempty"`
	Method             *ConfigAuthMethodUpdateInput             `json:"method,omitempty"`
	Redirections       *ConfigAuthRedirectionsUpdateInput       `json:"redirections,omitempty"`
	Resources          *ConfigResourcesUpdateInput              `json:"resources,omitempty"`
	Session            *ConfigAuthSessionUpdateInput            `json:"session,omitempty"`
	SignUp             *ConfigAuthSignUpUpdateInput             `json:"signUp,omitempty"`
	Totp               *ConfigAuthTotpUpdateInput               `json:"totp,omitempty"`
	User               *ConfigAuthUserUpdateInput               `json:"user,omitempty"`
	Version            *string                                  `json:"version,omitempty"`
}

type ConfigAuthUser 

type ConfigAuthUser struct {
	Email        *ConfigAuthUserEmail        `json:"email,omitempty"`
	EmailDomains *ConfigAuthUserEmailDomains `json:"emailDomains,omitempty"`
	Gravatar     *ConfigAuthUserGravatar     `json:"gravatar,omitempty"`
	Locale       *ConfigAuthUserLocale       `json:"locale,omitempty"`
	Roles        *ConfigAuthUserRoles        `json:"roles,omitempty"`
}

type ConfigAuthUserEmail 

type ConfigAuthUserEmail struct {
	Allowed []string `json:"allowed,omitempty"`
	Blocked []string `json:"blocked,omitempty"`
}

type ConfigAuthUserEmailDomains 

type ConfigAuthUserEmailDomains struct {
	Allowed []string `json:"allowed,omitempty"`
	Blocked []string `json:"blocked,omitempty"`
}

type ConfigAuthUserEmailDomainsUpdateInput 

type ConfigAuthUserEmailDomainsUpdateInput struct {
	Allowed []string `json:"allowed,omitempty"`
	Blocked []string `json:"blocked,omitempty"`
}

type ConfigAuthUserEmailUpdateInput 

type ConfigAuthUserEmailUpdateInput struct {
	Allowed []string `json:"allowed,omitempty"`
	Blocked []string `json:"blocked,omitempty"`
}

type ConfigAuthUserGravatar 

type ConfigAuthUserGravatar struct {
	Default *string `json:"default,omitempty"`
	Enabled *bool   `json:"enabled,omitempty"`
	Rating  *string `json:"rating,omitempty"`
}

type ConfigAuthUserGravatarUpdateInput 

type ConfigAuthUserGravatarUpdateInput struct {
	Default *string `json:"default,omitempty"`
	Enabled *bool   `json:"enabled,omitempty"`
	Rating  *string `json:"rating,omitempty"`
}

type ConfigAuthUserLocale 

type ConfigAuthUserLocale struct {
	Allowed []string `json:"allowed,omitempty"`
	Default *string  `json:"default,omitempty"`
}

type ConfigAuthUserLocaleUpdateInput 

type ConfigAuthUserLocaleUpdateInput struct {
	Allowed []string `json:"allowed,omitempty"`
	Default *string  `json:"default,omitempty"`
}

type ConfigAuthUserRoles 

type ConfigAuthUserRoles struct {
	Allowed []string `json:"allowed,omitempty"`
	Default *string  `json:"default,omitempty"`
}

type ConfigAuthUserRolesUpdateInput 

type ConfigAuthUserRolesUpdateInput struct {
	Allowed []string `json:"allowed,omitempty"`
	Default *string  `json:"default,omitempty"`
}

type ConfigAuthUserUpdateInput 

type ConfigAuthUserUpdateInput struct {
	Email        *ConfigAuthUserEmailUpdateInput        `json:"email,omitempty"`
	EmailDomains *ConfigAuthUserEmailDomainsUpdateInput `json:"emailDomains,omitempty"`
	Gravatar     *ConfigAuthUserGravatarUpdateInput     `json:"gravatar,omitempty"`
	Locale       *ConfigAuthUserLocaleUpdateInput       `json:"locale,omitempty"`
	Roles        *ConfigAuthUserRolesUpdateInput        `json:"roles,omitempty"`
}

type ConfigAuthsessionaccessTokenCustomClaims 

type ConfigAuthsessionaccessTokenCustomClaims struct {
	Key   string `json:"key"`
	Value string `json:"value"`
}

type ConfigAuthsessionaccessTokenCustomClaimsUpdateInput 

type ConfigAuthsessionaccessTokenCustomClaimsUpdateInput struct {
	Key   *string `json:"key,omitempty"`
	Value *string `json:"value,omitempty"`
}

type ConfigClaimMap 

type ConfigClaimMap struct {
	Claim   string  `json:"claim"`
	Default *string `json:"default,omitempty"`
	Path    *string `json:"path,omitempty"`
	Value   *string `json:"value,omitempty"`
}

type ConfigClaimMapUpdateInput 

type ConfigClaimMapUpdateInput struct {
	Claim   *string `json:"claim,omitempty"`
	Default *string `json:"default,omitempty"`
	Path    *string `json:"path,omitempty"`
	Value   *string `json:"value,omitempty"`
}

type ConfigComputeResources added in v1.10.0 

type ConfigComputeResources struct {
	CPU    uint32 `json:"cpu"`
	Memory uint32 `json:"memory"`
}

type ConfigComputeResourcesInsertInput added in v1.10.0 

type ConfigComputeResourcesInsertInput struct {
	CPU    uint32 `json:"cpu"`
	Memory uint32 `json:"memory"`
}

type ConfigComputeResourcesUpdateInput added in v1.10.0 

type ConfigComputeResourcesUpdateInput struct {
	CPU    *uint32 `json:"cpu,omitempty"`
	Memory *uint32 `json:"memory,omitempty"`
}

type ConfigConfig 

type ConfigConfig struct {
	Ai            *ConfigAi            `json:"ai,omitempty"`
	Auth          *ConfigAuth          `json:"auth,omitempty"`
	Functions     *ConfigFunctions     `json:"functions,omitempty"`
	Global        *ConfigGlobal        `json:"global,omitempty"`
	Graphql       *ConfigGraphql       `json:"graphql,omitempty"`
	Hasura        *ConfigHasura        `json:"hasura"`
	Observability *ConfigObservability `json:"observability"`
	Postgres      *ConfigPostgres      `json:"postgres,omitempty"`
	Provider      *ConfigProvider      `json:"provider,omitempty"`
	Storage       *ConfigStorage       `json:"storage,omitempty"`
}

type ConfigConfigUpdateInput 

type ConfigConfigUpdateInput struct {
	Ai            *ConfigAIUpdateInput            `json:"ai,omitempty"`
	Auth          *ConfigAuthUpdateInput          `json:"auth,omitempty"`
	Functions     *ConfigFunctionsUpdateInput     `json:"functions,omitempty"`
	Global        *ConfigGlobalUpdateInput        `json:"global,omitempty"`
	Graphql       *ConfigGraphqlUpdateInput       `json:"graphql,omitempty"`
	Hasura        *ConfigHasuraUpdateInput        `json:"hasura,omitempty"`
	Observability *ConfigObservabilityUpdateInput `json:"observability,omitempty"`
	Postgres      *ConfigPostgresUpdateInput      `json:"postgres,omitempty"`
	Provider      *ConfigProviderUpdateInput      `json:"provider,omitempty"`
	Storage       *ConfigStorageUpdateInput       `json:"storage,omitempty"`
}

type ConfigEnvironmentVariable 

type ConfigEnvironmentVariable struct {
	Name  string `json:"name"`
	Value string `json:"value"`
}

type ConfigEnvironmentVariableInsertInput 

type ConfigEnvironmentVariableInsertInput struct {
	Name  string `json:"name"`
	Value string `json:"value"`
}

type ConfigEnvironmentVariableUpdateInput 

type ConfigEnvironmentVariableUpdateInput struct {
	Name  *string `json:"name,omitempty"`
	Value *string `json:"value,omitempty"`
}

type ConfigFunctions 

type ConfigFunctions struct {
	Node      *ConfigFunctionsNode      `json:"node,omitempty"`
	Resources *ConfigFunctionsResources `json:"resources,omitempty"`
}

type ConfigFunctionsNode 

type ConfigFunctionsNode struct {
	Version *int64 `json:"version,omitempty"`
}

type ConfigFunctionsNodeUpdateInput 

type ConfigFunctionsNodeUpdateInput struct {
	Version *int64 `json:"version,omitempty"`
}

type ConfigFunctionsResources added in v1.9.4 

type ConfigFunctionsResources struct {
	Networking *ConfigNetworking `json:"networking,omitempty"`
}

type ConfigFunctionsResourcesUpdateInput added in v1.9.4 

type ConfigFunctionsResourcesUpdateInput struct {
	Networking *ConfigNetworkingUpdateInput `json:"networking,omitempty"`
}

type ConfigFunctionsUpdateInput 

type ConfigFunctionsUpdateInput struct {
	Node      *ConfigFunctionsNodeUpdateInput      `json:"node,omitempty"`
	Resources *ConfigFunctionsResourcesUpdateInput `json:"resources,omitempty"`
}

type ConfigGlobal 

type ConfigGlobal struct {
	Environment []*ConfigGlobalEnvironmentVariable `json:"environment,omitempty"`
}

type ConfigGlobalEnvironmentVariable added in v1.15.1 

type ConfigGlobalEnvironmentVariable struct {
	Name  string `json:"name"`
	Value string `json:"value"`
}

type ConfigGlobalEnvironmentVariableUpdateInput added in v1.15.1 

type ConfigGlobalEnvironmentVariableUpdateInput struct {
	Name  *string `json:"name,omitempty"`
	Value *string `json:"value,omitempty"`
}

type ConfigGlobalUpdateInput 

type ConfigGlobalUpdateInput struct {
	Environment []*ConfigGlobalEnvironmentVariableUpdateInput `json:"environment,omitempty"`
}

type ConfigGrafana 

type ConfigGrafana struct {
	AdminPassword string `json:"adminPassword"`
}

type ConfigGrafanaUpdateInput 

type ConfigGrafanaUpdateInput struct {
	AdminPassword *string `json:"adminPassword,omitempty"`
}

type ConfigGraphql added in v1.16.0 

type ConfigGraphql struct {
	Security *ConfigGraphqlSecurity `json:"security,omitempty"`
}

type ConfigGraphqlSecurity added in v1.16.0 

type ConfigGraphqlSecurity struct {
	ForbidAminSecret *bool   `json:"forbidAminSecret,omitempty"`
	MaxDepthQueries  *string `json:"maxDepthQueries,omitempty"`
}

type ConfigGraphqlSecurityUpdateInput added in v1.16.0 

type ConfigGraphqlSecurityUpdateInput struct {
	ForbidAminSecret *bool   `json:"forbidAminSecret,omitempty"`
	MaxDepthQueries  *string `json:"maxDepthQueries,omitempty"`
}

type ConfigGraphqlUpdateInput added in v1.16.0 

type ConfigGraphqlUpdateInput struct {
	Security *ConfigGraphqlSecurityUpdateInput `json:"security,omitempty"`
}

type ConfigHasura 

type ConfigHasura struct {
	AdminSecret   string                `json:"adminSecret"`
	AuthHook      *ConfigHasuraAuthHook `json:"authHook,omitempty"`
	Events        *ConfigHasuraEvents   `json:"events,omitempty"`
	JwtSecrets    []*ConfigJWTSecret    `json:"jwtSecrets,omitempty"`
	Logs          *ConfigHasuraLogs     `json:"logs,omitempty"`
	Resources     *ConfigResources      `json:"resources,omitempty"`
	Settings      *ConfigHasuraSettings `json:"settings,omitempty"`
	Version       *string               `json:"version,omitempty"`
	WebhookSecret string                `json:"webhookSecret"`
}

type ConfigHasuraAuthHook added in v1.15.3 

type ConfigHasuraAuthHook struct {
	Mode            *string `json:"mode,omitempty"`
	SendRequestBody *bool   `json:"sendRequestBody,omitempty"`
	URL             string  `json:"url"`
}

type ConfigHasuraAuthHookUpdateInput added in v1.15.3 

type ConfigHasuraAuthHookUpdateInput struct {
	Mode            *string `json:"mode,omitempty"`
	SendRequestBody *bool   `json:"sendRequestBody,omitempty"`
	URL             *string `json:"url,omitempty"`
}

type ConfigHasuraEvents 

type ConfigHasuraEvents struct {
	HTTPPoolSize *uint32 `json:"httpPoolSize,omitempty"`
}

type ConfigHasuraEventsUpdateInput 

type ConfigHasuraEventsUpdateInput struct {
	HTTPPoolSize *uint32 `json:"httpPoolSize,omitempty"`
}

type ConfigHasuraLogs 

type ConfigHasuraLogs struct {
	Level *string `json:"level,omitempty"`
}

type ConfigHasuraLogsUpdateInput 

type ConfigHasuraLogsUpdateInput struct {
	Level *string `json:"level,omitempty"`
}

type ConfigHasuraSettings 

type ConfigHasuraSettings struct {
	CorsDomain                            []string `json:"corsDomain,omitempty"`
	DevMode                               *bool    `json:"devMode,omitempty"`
	EnableAllowList                       *bool    `json:"enableAllowList,omitempty"`
	EnableConsole                         *bool    `json:"enableConsole,omitempty"`
	EnableRemoteSchemaPermissions         *bool    `json:"enableRemoteSchemaPermissions,omitempty"`
	EnabledAPIs                           []string `json:"enabledAPIs,omitempty"`
	LiveQueriesMultiplexedRefetchInterval *uint32  `json:"liveQueriesMultiplexedRefetchInterval,omitempty"`
	StringifyNumericTypes                 *bool    `json:"stringifyNumericTypes,omitempty"`
}

type ConfigHasuraSettingsUpdateInput 

type ConfigHasuraSettingsUpdateInput struct {
	CorsDomain                            []string `json:"corsDomain,omitempty"`
	DevMode                               *bool    `json:"devMode,omitempty"`
	EnableAllowList                       *bool    `json:"enableAllowList,omitempty"`
	EnableConsole                         *bool    `json:"enableConsole,omitempty"`
	EnableRemoteSchemaPermissions         *bool    `json:"enableRemoteSchemaPermissions,omitempty"`
	EnabledAPIs                           []string `json:"enabledAPIs,omitempty"`
	LiveQueriesMultiplexedRefetchInterval *uint32  `json:"liveQueriesMultiplexedRefetchInterval,omitempty"`
	StringifyNumericTypes                 *bool    `json:"stringifyNumericTypes,omitempty"`
}

type ConfigHasuraUpdateInput 

type ConfigHasuraUpdateInput struct {
	AdminSecret   *string                          `json:"adminSecret,omitempty"`
	AuthHook      *ConfigHasuraAuthHookUpdateInput `json:"authHook,omitempty"`
	Events        *ConfigHasuraEventsUpdateInput   `json:"events,omitempty"`
	JwtSecrets    []*ConfigJWTSecretUpdateInput    `json:"jwtSecrets,omitempty"`
	Logs          *ConfigHasuraLogsUpdateInput     `json:"logs,omitempty"`
	Resources     *ConfigResourcesUpdateInput      `json:"resources,omitempty"`
	Settings      *ConfigHasuraSettingsUpdateInput `json:"settings,omitempty"`
	Version       *string                          `json:"version,omitempty"`
	WebhookSecret *string                          `json:"webhookSecret,omitempty"`
}

type ConfigHealthCheck added in v1.10.0 

type ConfigHealthCheck struct {
	InitialDelaySeconds *int64 `json:"initialDelaySeconds,omitempty"`
	Port                uint32 `json:"port"`
	ProbePeriodSeconds  *int64 `json:"probePeriodSeconds,omitempty"`
}

type ConfigHealthCheckInsertInput added in v1.10.0 

type ConfigHealthCheckInsertInput struct {
	InitialDelaySeconds *int64 `json:"initialDelaySeconds,omitempty"`
	Port                uint32 `json:"port"`
	ProbePeriodSeconds  *int64 `json:"probePeriodSeconds,omitempty"`
}

type ConfigHealthCheckUpdateInput added in v1.10.0 

type ConfigHealthCheckUpdateInput struct {
	InitialDelaySeconds *int64  `json:"initialDelaySeconds,omitempty"`
	Port                *uint32 `json:"port,omitempty"`
	ProbePeriodSeconds  *int64  `json:"probePeriodSeconds,omitempty"`
}

type ConfigIngress added in v1.9.3 

type ConfigIngress struct {
	Fqdn []string `json:"fqdn,omitempty"`
}

type ConfigIngressInsertInput added in v1.9.3 

type ConfigIngressInsertInput struct {
	Fqdn []string `json:"fqdn,omitempty"`
}

type ConfigIngressUpdateInput added in v1.9.3 

type ConfigIngressUpdateInput struct {
	Fqdn []string `json:"fqdn,omitempty"`
}

type ConfigJWTSecret 

type ConfigJWTSecret struct {
	AllowedSkew         *uint32           `json:"allowed_skew,omitempty"`
	Audience            *string           `json:"audience,omitempty"`
	ClaimsFormat        *string           `json:"claims_format,omitempty"`
	ClaimsMap           []*ConfigClaimMap `json:"claims_map,omitempty"`
	ClaimsNamespace     *string           `json:"claims_namespace,omitempty"`
	ClaimsNamespacePath *string           `json:"claims_namespace_path,omitempty"`
	Header              *string           `json:"header,omitempty"`
	Issuer              *string           `json:"issuer,omitempty"`
	JwkURL              *string           `json:"jwk_url,omitempty"`
	Key                 *string           `json:"key,omitempty"`
	Type                *string           `json:"type,omitempty"`
}

type ConfigJWTSecretUpdateInput 

type ConfigJWTSecretUpdateInput struct {
	AllowedSkew         *uint32                      `json:"allowed_skew,omitempty"`
	Audience            *string                      `json:"audience,omitempty"`
	ClaimsFormat        *string                      `json:"claims_format,omitempty"`
	ClaimsMap           []*ConfigClaimMapUpdateInput `json:"claims_map,omitempty"`
	ClaimsNamespace     *string                      `json:"claims_namespace,omitempty"`
	ClaimsNamespacePath *string                      `json:"claims_namespace_path,omitempty"`
	Header              *string                      `json:"header,omitempty"`
	Issuer              *string                      `json:"issuer,omitempty"`
	JwkURL              *string                      `json:"jwk_url,omitempty"`
	Key                 *string                      `json:"key,omitempty"`
	Type                *string                      `json:"type,omitempty"`
}

type ConfigNetworking added in v1.9.3 

type ConfigNetworking struct {
	Ingresses []*ConfigIngress `json:"ingresses,omitempty"`
}

type ConfigNetworkingUpdateInput added in v1.9.3 

type ConfigNetworkingUpdateInput struct {
	Ingresses []*ConfigIngressUpdateInput `json:"ingresses,omitempty"`
}

type ConfigObservability 

type ConfigObservability struct {
	Grafana *ConfigGrafana `json:"grafana"`
}

type ConfigObservabilityUpdateInput 

type ConfigObservabilityUpdateInput struct {
	Grafana *ConfigGrafanaUpdateInput `json:"grafana,omitempty"`
}

type ConfigPostgres 

type ConfigPostgres struct {
	Resources *ConfigPostgresResources `json:"resources,omitempty"`
	Settings  *ConfigPostgresSettings  `json:"settings,omitempty"`
	Version   *string                  `json:"version,omitempty"`
}

type ConfigPostgresResources added in v1.9.3 

type ConfigPostgresResources struct {
	Compute            *ConfigResourcesCompute `json:"compute,omitempty"`
	EnablePublicAccess *bool                   `json:"enablePublicAccess,omitempty"`
	Networking         *ConfigNetworking       `json:"networking,omitempty"`
	Replicas           *uint32                 `json:"replicas,omitempty"`
	Storage            *ConfigPostgresStorage  `json:"storage,omitempty"`
}

type ConfigPostgresResourcesUpdateInput added in v1.9.3 

type ConfigPostgresResourcesUpdateInput struct {
	Compute            *ConfigResourcesComputeUpdateInput `json:"compute,omitempty"`
	EnablePublicAccess *bool                              `json:"enablePublicAccess,omitempty"`
	Networking         *ConfigNetworkingUpdateInput       `json:"networking,omitempty"`
	Replicas           *uint32                            `json:"replicas,omitempty"`
	Storage            *ConfigPostgresStorageUpdateInput  `json:"storage,omitempty"`
}

type ConfigPostgresSettings added in v1.9.3 

type ConfigPostgresSettings struct {
	CheckpointCompletionTarget    *float64 `json:"checkpointCompletionTarget,omitempty"`
	DefaultStatisticsTarget       *string  `json:"defaultStatisticsTarget,omitempty"`
	EffectiveCacheSize            *string  `json:"effectiveCacheSize,omitempty"`
	EffectiveIOConcurrency        *string  `json:"effectiveIOConcurrency,omitempty"`
	HugePages                     *string  `json:"hugePages,omitempty"`
	Jit                           *string  `json:"jit,omitempty"`
	MaintenanceWorkMem            *string  `json:"maintenanceWorkMem,omitempty"`
	MaxConnections                *string  `json:"maxConnections,omitempty"`
	MaxParallelMaintenanceWorkers *string  `json:"maxParallelMaintenanceWorkers,omitempty"`
	MaxParallelWorkers            *string  `json:"maxParallelWorkers,omitempty"`
	MaxParallelWorkersPerGather   *string  `json:"maxParallelWorkersPerGather,omitempty"`
	MaxReplicationSlots           *string  `json:"maxReplicationSlots,omitempty"`
	MaxWalSenders                 *string  `json:"maxWalSenders,omitempty"`
	MaxWalSize                    *string  `json:"maxWalSize,omitempty"`
	MaxWorkerProcesses            *string  `json:"maxWorkerProcesses,omitempty"`
	MinWalSize                    *string  `json:"minWalSize,omitempty"`
	RandomPageCost                *float64 `json:"randomPageCost,omitempty"`
	SharedBuffers                 *string  `json:"sharedBuffers,omitempty"`
	WalBuffers                    *string  `json:"walBuffers,omitempty"`
	WalLevel                      *string  `json:"walLevel,omitempty"`
	WorkMem                       *string  `json:"workMem,omitempty"`
}

type ConfigPostgresSettingsUpdateInput added in v1.9.3 

type ConfigPostgresSettingsUpdateInput struct {
	CheckpointCompletionTarget    *float64 `json:"checkpointCompletionTarget,omitempty"`
	DefaultStatisticsTarget       *string  `json:"defaultStatisticsTarget,omitempty"`
	EffectiveCacheSize            *string  `json:"effectiveCacheSize,omitempty"`
	EffectiveIOConcurrency        *string  `json:"effectiveIOConcurrency,omitempty"`
	HugePages                     *string  `json:"hugePages,omitempty"`
	Jit                           *string  `json:"jit,omitempty"`
	MaintenanceWorkMem            *string  `json:"maintenanceWorkMem,omitempty"`
	MaxConnections                *string  `json:"maxConnections,omitempty"`
	MaxParallelMaintenanceWorkers *string  `json:"maxParallelMaintenanceWorkers,omitempty"`
	MaxParallelWorkers            *string  `json:"maxParallelWorkers,omitempty"`
	MaxParallelWorkersPerGather   *string  `json:"maxParallelWorkersPerGather,omitempty"`
	MaxReplicationSlots           *string  `json:"maxReplicationSlots,omitempty"`
	MaxWalSenders                 *string  `json:"maxWalSenders,omitempty"`
	MaxWalSize                    *string  `json:"maxWalSize,omitempty"`
	MaxWorkerProcesses            *string  `json:"maxWorkerProcesses,omitempty"`
	MinWalSize                    *string  `json:"minWalSize,omitempty"`
	RandomPageCost                *float64 `json:"randomPageCost,omitempty"`
	SharedBuffers                 *string  `json:"sharedBuffers,omitempty"`
	WalBuffers                    *string  `json:"walBuffers,omitempty"`
	WalLevel                      *string  `json:"walLevel,omitempty"`
	WorkMem                       *string  `json:"workMem,omitempty"`
}

type ConfigPostgresStorage added in v1.9.3 

type ConfigPostgresStorage struct {
	Capacity uint32 `json:"capacity"`
}

type ConfigPostgresStorageUpdateInput added in v1.9.3 

type ConfigPostgresStorageUpdateInput struct {
	Capacity *uint32 `json:"capacity,omitempty"`
}

type ConfigPostgresUpdateInput 

type ConfigPostgresUpdateInput struct {
	Resources *ConfigPostgresResourcesUpdateInput `json:"resources,omitempty"`
	Settings  *ConfigPostgresSettingsUpdateInput  `json:"settings,omitempty"`
	Version   *string                             `json:"version,omitempty"`
}

type ConfigProvider 

type ConfigProvider struct {
	Sms  *ConfigSms  `json:"sms,omitempty"`
	SMTP *ConfigSMTP `json:"smtp,omitempty"`
}

type ConfigProviderUpdateInput 

type ConfigProviderUpdateInput struct {
	Sms  *ConfigSmsUpdateInput  `json:"sms,omitempty"`
	SMTP *ConfigSMTPUpdateInput `json:"smtp,omitempty"`
}

type ConfigResources 

type ConfigResources struct {
	Compute    *ConfigResourcesCompute `json:"compute,omitempty"`
	Networking *ConfigNetworking       `json:"networking,omitempty"`
	Replicas   *uint32                 `json:"replicas,omitempty"`
}

type ConfigResourcesCompute 

type ConfigResourcesCompute struct {
	CPU    uint32 `json:"cpu"`
	Memory uint32 `json:"memory"`
}

type ConfigResourcesComputeUpdateInput 

type ConfigResourcesComputeUpdateInput struct {
	CPU    *uint32 `json:"cpu,omitempty"`
	Memory *uint32 `json:"memory,omitempty"`
}

type ConfigResourcesUpdateInput 

type ConfigResourcesUpdateInput struct {
	Compute    *ConfigResourcesComputeUpdateInput `json:"compute,omitempty"`
	Networking *ConfigNetworkingUpdateInput       `json:"networking,omitempty"`
	Replicas   *uint32                            `json:"replicas,omitempty"`
}

type ConfigRunServiceConfig added in v1.5.0 

type ConfigRunServiceConfig struct {
	Command     []string                     `json:"command,omitempty"`
	Environment []*ConfigEnvironmentVariable `json:"environment,omitempty"`
	HealthCheck *ConfigHealthCheck           `json:"healthCheck,omitempty"`
	Image       *ConfigRunServiceImage       `json:"image"`
	Name        string                       `json:"name"`
	Ports       []*ConfigRunServicePort      `json:"ports,omitempty"`
	Resources   *ConfigRunServiceResources   `json:"resources"`
}

type ConfigRunServiceConfigInsertInput added in v1.5.0 

type ConfigRunServiceConfigInsertInput struct {
	Command     []string                                `json:"command,omitempty"`
	Environment []*ConfigEnvironmentVariableInsertInput `json:"environment,omitempty"`
	HealthCheck *ConfigHealthCheckInsertInput           `json:"healthCheck,omitempty"`
	Image       *ConfigRunServiceImageInsertInput       `json:"image"`
	Name        string                                  `json:"name"`
	Ports       []*ConfigRunServicePortInsertInput      `json:"ports,omitempty"`
	Resources   *ConfigRunServiceResourcesInsertInput   `json:"resources"`
}

type ConfigRunServiceConfigUpdateInput added in v1.5.0 

type ConfigRunServiceConfigUpdateInput struct {
	Command     []string                                `json:"command,omitempty"`
	Environment []*ConfigEnvironmentVariableUpdateInput `json:"environment,omitempty"`
	HealthCheck *ConfigHealthCheckUpdateInput           `json:"healthCheck,omitempty"`
	Image       *ConfigRunServiceImageUpdateInput       `json:"image,omitempty"`
	Name        *string                                 `json:"name,omitempty"`
	Ports       []*ConfigRunServicePortUpdateInput      `json:"ports,omitempty"`
	Resources   *ConfigRunServiceResourcesUpdateInput   `json:"resources,omitempty"`
}

type ConfigRunServiceConfigWithID added in v1.5.0 

type ConfigRunServiceConfigWithID struct {
	Config    *ConfigRunServiceConfig `json:"config"`
	ServiceID string                  `json:"serviceID"`
}

type ConfigRunServiceImage added in v1.5.0 

type ConfigRunServiceImage struct {
	Image string `json:"image"`
}

type ConfigRunServiceImageInsertInput added in v1.5.0 

type ConfigRunServiceImageInsertInput struct {
	Image string `json:"image"`
}

type ConfigRunServiceImageUpdateInput added in v1.5.0 

type ConfigRunServiceImageUpdateInput struct {
	Image *string `json:"image,omitempty"`
}

type ConfigRunServicePort added in v1.5.0 

type ConfigRunServicePort struct {
	Ingresses []*ConfigIngress `json:"ingresses,omitempty"`
	Port      uint32           `json:"port"`
	Publish   *bool            `json:"publish,omitempty"`
	Type      string           `json:"type"`
}

type ConfigRunServicePortInsertInput added in v1.5.0 

type ConfigRunServicePortInsertInput struct {
	Ingresses []*ConfigIngressInsertInput `json:"ingresses,omitempty"`
	Port      uint32                      `json:"port"`
	Publish   *bool                       `json:"publish,omitempty"`
	Type      string                      `json:"type"`
}

type ConfigRunServicePortUpdateInput added in v1.5.0 

type ConfigRunServicePortUpdateInput struct {
	Ingresses []*ConfigIngressUpdateInput `json:"ingresses,omitempty"`
	Port      *uint32                     `json:"port,omitempty"`
	Publish   *bool                       `json:"publish,omitempty"`
	Type      *string                     `json:"type,omitempty"`
}

type ConfigRunServiceResources added in v1.5.0 

type ConfigRunServiceResources struct {
	Compute  *ConfigComputeResources             `json:"compute"`
	Replicas uint32                              `json:"replicas"`
	Storage  []*ConfigRunServiceResourcesStorage `json:"storage,omitempty"`
}

type ConfigRunServiceResourcesInsertInput added in v1.5.0 

type ConfigRunServiceResourcesInsertInput struct {
	Compute  *ConfigComputeResourcesInsertInput             `json:"compute"`
	Replicas uint32                                         `json:"replicas"`
	Storage  []*ConfigRunServiceResourcesStorageInsertInput `json:"storage,omitempty"`
}

type ConfigRunServiceResourcesStorage added in v1.5.0 

type ConfigRunServiceResourcesStorage struct {
	Capacity uint32 `json:"capacity"`
	Name     string `json:"name"`
	Path     string `json:"path"`
}

type ConfigRunServiceResourcesStorageInsertInput added in v1.5.0 

type ConfigRunServiceResourcesStorageInsertInput struct {
	Capacity uint32 `json:"capacity"`
	Name     string `json:"name"`
	Path     string `json:"path"`
}

type ConfigRunServiceResourcesStorageUpdateInput added in v1.5.0 

type ConfigRunServiceResourcesStorageUpdateInput struct {
	Capacity *uint32 `json:"capacity,omitempty"`
	Name     *string `json:"name,omitempty"`
	Path     *string `json:"path,omitempty"`
}

type ConfigRunServiceResourcesUpdateInput added in v1.5.0 

type ConfigRunServiceResourcesUpdateInput struct {
	Compute  *ConfigComputeResourcesUpdateInput             `json:"compute,omitempty"`
	Replicas *uint32                                        `json:"replicas,omitempty"`
	Storage  []*ConfigRunServiceResourcesStorageUpdateInput `json:"storage,omitempty"`
}

type ConfigSMTP 

type ConfigSMTP struct {
	Host     string `json:"host"`
	Method   string `json:"method"`
	Password string `json:"password"`
	Port     uint32 `json:"port"`
	Secure   bool   `json:"secure"`
	Sender   string `json:"sender"`
	User     string `json:"user"`
}

type ConfigSMTPUpdateInput 

type ConfigSMTPUpdateInput struct {
	Host     *string `json:"host,omitempty"`
	Method   *string `json:"method,omitempty"`
	Password *string `json:"password,omitempty"`
	Port     *uint32 `json:"port,omitempty"`
	Secure   *bool   `json:"secure,omitempty"`
	Sender   *string `json:"sender,omitempty"`
	User     *string `json:"user,omitempty"`
}

type ConfigSms 

type ConfigSms struct {
	AccountSid         string  `json:"accountSid"`
	AuthToken          string  `json:"authToken"`
	MessagingServiceID string  `json:"messagingServiceId"`
	Provider           *string `json:"provider,omitempty"`
}

type ConfigSmsUpdateInput 

type ConfigSmsUpdateInput struct {
	AccountSid         *string `json:"accountSid,omitempty"`
	AuthToken          *string `json:"authToken,omitempty"`
	MessagingServiceID *string `json:"messagingServiceId,omitempty"`
	Provider           *string `json:"provider,omitempty"`
}

type ConfigStandardOauthProvider 

type ConfigStandardOauthProvider struct {
	ClientID     *string `json:"clientId,omitempty"`
	ClientSecret *string `json:"clientSecret,omitempty"`
	Enabled      *bool   `json:"enabled,omitempty"`
}

type ConfigStandardOauthProviderUpdateInput 

type ConfigStandardOauthProviderUpdateInput struct {
	ClientID     *string `json:"clientId,omitempty"`
	ClientSecret *string `json:"clientSecret,omitempty"`
	Enabled      *bool   `json:"enabled,omitempty"`
}

type ConfigStandardOauthProviderWithScope 

type ConfigStandardOauthProviderWithScope struct {
	ClientID     *string  `json:"clientId,omitempty"`
	ClientSecret *string  `json:"clientSecret,omitempty"`
	Enabled      *bool    `json:"enabled,omitempty"`
	Scope        []string `json:"scope,omitempty"`
}

type ConfigStandardOauthProviderWithScopeUpdateInput 

type ConfigStandardOauthProviderWithScopeUpdateInput struct {
	ClientID     *string  `json:"clientId,omitempty"`
	ClientSecret *string  `json:"clientSecret,omitempty"`
	Enabled      *bool    `json:"enabled,omitempty"`
	Scope        []string `json:"scope,omitempty"`
}

type ConfigStorage 

type ConfigStorage struct {
	Antivirus *ConfigStorageAntivirus `json:"antivirus,omitempty"`
	Resources *ConfigResources        `json:"resources,omitempty"`
	Version   *string                 `json:"version,omitempty"`
}

type ConfigStorageAntivirus added in v1.9.3 

type ConfigStorageAntivirus struct {
	Server *string `json:"server,omitempty"`
}

type ConfigStorageAntivirusUpdateInput added in v1.9.3 

type ConfigStorageAntivirusUpdateInput struct {
	Server *string `json:"server,omitempty"`
}

type ConfigStorageUpdateInput 

type ConfigStorageUpdateInput struct {
	Antivirus *ConfigStorageAntivirusUpdateInput `json:"antivirus,omitempty"`
	Resources *ConfigResourcesUpdateInput        `json:"resources,omitempty"`
	Version   *string                            `json:"version,omitempty"`
}

type ConfigSystemConfig 

type ConfigSystemConfig struct {
	Auth     *ConfigSystemConfigAuth     `json:"auth,omitempty"`
	Graphql  *ConfigSystemConfigGraphql  `json:"graphql,omitempty"`
	Postgres *ConfigSystemConfigPostgres `json:"postgres"`
}

type ConfigSystemConfigAuth 

type ConfigSystemConfigAuth struct {
	Email *ConfigSystemConfigAuthEmail `json:"email,omitempty"`
}

type ConfigSystemConfigAuthEmail 

type ConfigSystemConfigAuthEmail struct {
	Templates *ConfigSystemConfigAuthEmailTemplates `json:"templates,omitempty"`
}

type ConfigSystemConfigAuthEmailTemplates 

type ConfigSystemConfigAuthEmailTemplates struct {
	S3Key *string `json:"s3Key,omitempty"`
}

type ConfigSystemConfigGraphql added in v1.16.0 

type ConfigSystemConfigGraphql struct {
	FeatureAdvancedGraphql *bool `json:"featureAdvancedGraphql,omitempty"`
}

type ConfigSystemConfigPostgres 

type ConfigSystemConfigPostgres struct {
	ConnectionString *ConfigSystemConfigPostgresConnectionString `json:"connectionString"`
	Database         string                                      `json:"database"`
	Disk             *ConfigSystemConfigPostgresDisk             `json:"disk,omitempty"`
	Enabled          *bool                                       `json:"enabled,omitempty"`
	MajorVersion     *string                                     `json:"majorVersion,omitempty"`
}

type ConfigSystemConfigPostgresConnectionString 

type ConfigSystemConfigPostgresConnectionString struct {
	Auth    string `json:"auth"`
	Backup  string `json:"backup"`
	Hasura  string `json:"hasura"`
	Storage string `json:"storage"`
}

type ConfigSystemConfigPostgresDisk added in v1.16.5 

type ConfigSystemConfigPostgresDisk struct {
	Iops *uint32 `json:"iops,omitempty"`
	Tput *uint32 `json:"tput,omitempty"`
}

type ContainerError added in v1.18.1 

type ContainerError struct {
	LastError *LastError `json:"lastError"`
	Name      string     `json:"name"`
}

type Continents 

type Continents struct {
	// Continent code
	Code string `json:"code"`
	// An array relationship
	Countries []*Countries `json:"countries"`
	// Continent name
	Name *string `json:"name,omitempty"`
}

columns and relationships of "continents"

type ContinentsBoolExp 

type ContinentsBoolExp struct {
	And       []*ContinentsBoolExp `json:"_and,omitempty"`
	Not       *ContinentsBoolExp   `json:"_not,omitempty"`
	Or        []*ContinentsBoolExp `json:"_or,omitempty"`
	Code      *BpcharComparisonExp `json:"code,omitempty"`
	Countries *CountriesBoolExp    `json:"countries,omitempty"`
	Name      *StringComparisonExp `json:"name,omitempty"`
}

Boolean expression to filter rows from the table "continents". All fields are combined with a logical 'AND'.

type ContinentsOrderBy 

type ContinentsOrderBy struct {
	Code               *OrderBy                   `json:"code,omitempty"`
	CountriesAggregate *CountriesAggregateOrderBy `json:"countries_aggregate,omitempty"`
	Name               *OrderBy                   `json:"name,omitempty"`
}

Ordering options when selecting data from "continents".

type ContinentsSelectColumn 

type ContinentsSelectColumn string

select columns of table "continents" 

const (
	// column name
	ContinentsSelectColumnCode ContinentsSelectColumn = "code"
	// column name
	ContinentsSelectColumnName ContinentsSelectColumn = "name"
)

func (ContinentsSelectColumn) IsValid 

func (e ContinentsSelectColumn) IsValid() bool

func (ContinentsSelectColumn) MarshalGQL 

func (e ContinentsSelectColumn) MarshalGQL(w io.Writer)

func (ContinentsSelectColumn) String 

func (e ContinentsSelectColumn) String() string

func (*ContinentsSelectColumn) UnmarshalGQL 

func (e *ContinentsSelectColumn) UnmarshalGQL(v interface{}) error

type ContinentsStreamCursorInput 

type ContinentsStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *ContinentsStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "continents"

type ContinentsStreamCursorValueInput 

type ContinentsStreamCursorValueInput struct {
	// Continent code
	Code *string `json:"code,omitempty"`
	// Continent name
	Name *string `json:"name,omitempty"`
}

Initial value of the column from where the streaming should start

type Countries 

type Countries struct {
	// Two-letter country code (ISO 3166-1 alpha-2)
	Code string `json:"code"`
	// An object relationship
	Continent     *Continents `json:"continent"`
	ContinentCode string      `json:"continentCode"`
	EmojiFlag     *string     `json:"emojiFlag,omitempty"`
	// An array relationship
	Locations []*Regions `json:"locations"`
	// English country name
	Name string `json:"name"`
	// An array relationship
	Workspaces []*Workspaces `json:"workspaces"`
}

columns and relationships of "countries"

type CountriesAggregateOrderBy 

type CountriesAggregateOrderBy struct {
	Count *OrderBy             `json:"count,omitempty"`
	Max   *CountriesMaxOrderBy `json:"max,omitempty"`
	Min   *CountriesMinOrderBy `json:"min,omitempty"`
}

order by aggregate values of table "countries"

type CountriesBoolExp 

type CountriesBoolExp struct {
	And           []*CountriesBoolExp  `json:"_and,omitempty"`
	Not           *CountriesBoolExp    `json:"_not,omitempty"`
	Or            []*CountriesBoolExp  `json:"_or,omitempty"`
	Code          *BpcharComparisonExp `json:"code,omitempty"`
	Continent     *ContinentsBoolExp   `json:"continent,omitempty"`
	ContinentCode *BpcharComparisonExp `json:"continentCode,omitempty"`
	EmojiFlag     *StringComparisonExp `json:"emojiFlag,omitempty"`
	Locations     *RegionsBoolExp      `json:"locations,omitempty"`
	Name          *StringComparisonExp `json:"name,omitempty"`
	Workspaces    *WorkspacesBoolExp   `json:"workspaces,omitempty"`
}

Boolean expression to filter rows from the table "countries". All fields are combined with a logical 'AND'.

type CountriesMaxOrderBy 

type CountriesMaxOrderBy struct {
	// Two-letter country code (ISO 3166-1 alpha-2)
	Code          *OrderBy `json:"code,omitempty"`
	ContinentCode *OrderBy `json:"continentCode,omitempty"`
	EmojiFlag     *OrderBy `json:"emojiFlag,omitempty"`
	// English country name
	Name *OrderBy `json:"name,omitempty"`
}

order by max() on columns of table "countries"

type CountriesMinOrderBy 

type CountriesMinOrderBy struct {
	// Two-letter country code (ISO 3166-1 alpha-2)
	Code          *OrderBy `json:"code,omitempty"`
	ContinentCode *OrderBy `json:"continentCode,omitempty"`
	EmojiFlag     *OrderBy `json:"emojiFlag,omitempty"`
	// English country name
	Name *OrderBy `json:"name,omitempty"`
}

order by min() on columns of table "countries"

type CountriesOrderBy 

type CountriesOrderBy struct {
	Code                *OrderBy                    `json:"code,omitempty"`
	Continent           *ContinentsOrderBy          `json:"continent,omitempty"`
	ContinentCode       *OrderBy                    `json:"continentCode,omitempty"`
	EmojiFlag           *OrderBy                    `json:"emojiFlag,omitempty"`
	LocationsAggregate  *RegionsAggregateOrderBy    `json:"locations_aggregate,omitempty"`
	Name                *OrderBy                    `json:"name,omitempty"`
	WorkspacesAggregate *WorkspacesAggregateOrderBy `json:"workspaces_aggregate,omitempty"`
}

Ordering options when selecting data from "countries".

type CountriesSelectColumn 

type CountriesSelectColumn string

select columns of table "countries" 

const (
	// column name
	CountriesSelectColumnCode CountriesSelectColumn = "code"
	// column name
	CountriesSelectColumnContinentCode CountriesSelectColumn = "continentCode"
	// column name
	CountriesSelectColumnEmojiFlag CountriesSelectColumn = "emojiFlag"
	// column name
	CountriesSelectColumnName CountriesSelectColumn = "name"
)

func (CountriesSelectColumn) IsValid 

func (e CountriesSelectColumn) IsValid() bool

func (CountriesSelectColumn) MarshalGQL 

func (e CountriesSelectColumn) MarshalGQL(w io.Writer)

func (CountriesSelectColumn) String 

func (e CountriesSelectColumn) String() string

func (*CountriesSelectColumn) UnmarshalGQL 

func (e *CountriesSelectColumn) UnmarshalGQL(v interface{}) error

type CountriesStreamCursorInput 

type CountriesStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *CountriesStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "countries"

type CountriesStreamCursorValueInput 

type CountriesStreamCursorValueInput struct {
	// Two-letter country code (ISO 3166-1 alpha-2)
	Code          *string `json:"code,omitempty"`
	ContinentCode *string `json:"continentCode,omitempty"`
	EmojiFlag     *string `json:"emojiFlag,omitempty"`
	// English country name
	Name *string `json:"name,omitempty"`
}

Initial value of the column from where the streaming should start

type CreateSecret 

type CreateSecret struct {
	InsertSecret CreateSecret_InsertSecret "json:\"insertSecret\" graphql:\"insertSecret\""
}

func (*CreateSecret) GetInsertSecret 

func (t *CreateSecret) GetInsertSecret() *CreateSecret_InsertSecret

type CreateSecret_InsertSecret 

type CreateSecret_InsertSecret struct {
	Name  string "json:\"name\" graphql:\"name\""
	Value string "json:\"value\" graphql:\"value\""
}

func (*CreateSecret_InsertSecret) GetName 

func (t *CreateSecret_InsertSecret) GetName() string

func (*CreateSecret_InsertSecret) GetValue 

func (t *CreateSecret_InsertSecret) GetValue() string

type CursorOrdering 

type CursorOrdering string

ordering argument of a cursor 

const (
	// ascending ordering of the cursor
	CursorOrderingAsc CursorOrdering = "ASC"
	// descending ordering of the cursor
	CursorOrderingDesc CursorOrdering = "DESC"
)

func (CursorOrdering) IsValid 

func (e CursorOrdering) IsValid() bool

func (CursorOrdering) MarshalGQL 

func (e CursorOrdering) MarshalGQL(w io.Writer)

func (CursorOrdering) String 

func (e CursorOrdering) String() string

func (*CursorOrdering) UnmarshalGQL 

func (e *CursorOrdering) UnmarshalGQL(v interface{}) error

type DeleteRefreshToken 

type DeleteRefreshToken struct {
	DeleteAuthRefreshTokens *DeleteRefreshToken_DeleteAuthRefreshTokens "json:\"deleteAuthRefreshTokens,omitempty\" graphql:\"deleteAuthRefreshTokens\""
}

func (*DeleteRefreshToken) GetDeleteAuthRefreshTokens 

func (t *DeleteRefreshToken) GetDeleteAuthRefreshTokens() *DeleteRefreshToken_DeleteAuthRefreshTokens

type DeleteRefreshToken_DeleteAuthRefreshTokens 

type DeleteRefreshToken_DeleteAuthRefreshTokens struct {
	AffectedRows int64                                                   "json:\"affected_rows\" graphql:\"affected_rows\""
	Returning    []*DeleteRefreshToken_DeleteAuthRefreshTokens_Returning "json:\"returning\" graphql:\"returning\""
}

func (*DeleteRefreshToken_DeleteAuthRefreshTokens) GetAffectedRows 

func (t *DeleteRefreshToken_DeleteAuthRefreshTokens) GetAffectedRows() int64

func (*DeleteRefreshToken_DeleteAuthRefreshTokens) GetReturning 

func (t *DeleteRefreshToken_DeleteAuthRefreshTokens) GetReturning() []*DeleteRefreshToken_DeleteAuthRefreshTokens_Returning

type DeleteRefreshToken_DeleteAuthRefreshTokens_Returning 

type DeleteRefreshToken_DeleteAuthRefreshTokens_Returning struct {
	Typename *string "json:\"__typename,omitempty\" graphql:\"__typename\""
}

func (*DeleteRefreshToken_DeleteAuthRefreshTokens_Returning) GetTypename added in v1.5.0 

func (t *DeleteRefreshToken_DeleteAuthRefreshTokens_Returning) GetTypename() *string

type DeleteSecret 

type DeleteSecret struct {
	DeleteSecret *DeleteSecret_DeleteSecret "json:\"deleteSecret,omitempty\" graphql:\"deleteSecret\""
}

func (*DeleteSecret) GetDeleteSecret 

func (t *DeleteSecret) GetDeleteSecret() *DeleteSecret_DeleteSecret

type DeleteSecret_DeleteSecret 

type DeleteSecret_DeleteSecret struct {
	Name string "json:\"name\" graphql:\"name\""
}

func (*DeleteSecret_DeleteSecret) GetName 

func (t *DeleteSecret_DeleteSecret) GetName() string

type DeploymentLogs 

type DeploymentLogs struct {
	CreatedAt time.Time `json:"createdAt"`
	// An object relationship
	Deployment   *Deployments `json:"deployment"`
	DeploymentID string       `json:"deploymentId"`
	ID           string       `json:"id"`
	Message      string       `json:"message"`
}

columns and relationships of "deployment_logs"

type DeploymentLogsAggregateOrderBy 

type DeploymentLogsAggregateOrderBy struct {
	Count *OrderBy                  `json:"count,omitempty"`
	Max   *DeploymentLogsMaxOrderBy `json:"max,omitempty"`
	Min   *DeploymentLogsMinOrderBy `json:"min,omitempty"`
}

order by aggregate values of table "deployment_logs"

type DeploymentLogsBoolExp 

type DeploymentLogsBoolExp struct {
	And          []*DeploymentLogsBoolExp  `json:"_and,omitempty"`
	Not          *DeploymentLogsBoolExp    `json:"_not,omitempty"`
	Or           []*DeploymentLogsBoolExp  `json:"_or,omitempty"`
	CreatedAt    *TimestamptzComparisonExp `json:"createdAt,omitempty"`
	Deployment   *DeploymentsBoolExp       `json:"deployment,omitempty"`
	DeploymentID *UUIDComparisonExp        `json:"deploymentId,omitempty"`
	ID           *UUIDComparisonExp        `json:"id,omitempty"`
	Message      *StringComparisonExp      `json:"message,omitempty"`
}

Boolean expression to filter rows from the table "deployment_logs". All fields are combined with a logical 'AND'.

type DeploymentLogsMaxOrderBy 

type DeploymentLogsMaxOrderBy struct {
	CreatedAt    *OrderBy `json:"createdAt,omitempty"`
	DeploymentID *OrderBy `json:"deploymentId,omitempty"`
	ID           *OrderBy `json:"id,omitempty"`
	Message      *OrderBy `json:"message,omitempty"`
}

order by max() on columns of table "deployment_logs"

type DeploymentLogsMinOrderBy 

type DeploymentLogsMinOrderBy struct {
	CreatedAt    *OrderBy `json:"createdAt,omitempty"`
	DeploymentID *OrderBy `json:"deploymentId,omitempty"`
	ID           *OrderBy `json:"id,omitempty"`
	Message      *OrderBy `json:"message,omitempty"`
}

order by min() on columns of table "deployment_logs"

type DeploymentLogsOrderBy 

type DeploymentLogsOrderBy struct {
	CreatedAt    *OrderBy            `json:"createdAt,omitempty"`
	Deployment   *DeploymentsOrderBy `json:"deployment,omitempty"`
	DeploymentID *OrderBy            `json:"deploymentId,omitempty"`
	ID           *OrderBy            `json:"id,omitempty"`
	Message      *OrderBy            `json:"message,omitempty"`
}

Ordering options when selecting data from "deployment_logs".

type DeploymentLogsSelectColumn 

type DeploymentLogsSelectColumn string

select columns of table "deployment_logs" 

const (
	// column name
	DeploymentLogsSelectColumnCreatedAt DeploymentLogsSelectColumn = "createdAt"
	// column name
	DeploymentLogsSelectColumnDeploymentID DeploymentLogsSelectColumn = "deploymentId"
	// column name
	DeploymentLogsSelectColumnID DeploymentLogsSelectColumn = "id"
	// column name
	DeploymentLogsSelectColumnMessage DeploymentLogsSelectColumn = "message"
)

func (DeploymentLogsSelectColumn) IsValid 

func (e DeploymentLogsSelectColumn) IsValid() bool

func (DeploymentLogsSelectColumn) MarshalGQL 

func (e DeploymentLogsSelectColumn) MarshalGQL(w io.Writer)

func (DeploymentLogsSelectColumn) String 

func (e DeploymentLogsSelectColumn) String() string

func (*DeploymentLogsSelectColumn) UnmarshalGQL 

func (e *DeploymentLogsSelectColumn) UnmarshalGQL(v interface{}) error

type DeploymentLogsStreamCursorInput 

type DeploymentLogsStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *DeploymentLogsStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "deploymentLogs"

type DeploymentLogsStreamCursorValueInput 

type DeploymentLogsStreamCursorValueInput struct {
	CreatedAt    *time.Time `json:"createdAt,omitempty"`
	DeploymentID *string    `json:"deploymentId,omitempty"`
	ID           *string    `json:"id,omitempty"`
	Message      *string    `json:"message,omitempty"`
}

Initial value of the column from where the streaming should start

type Deployments 

type Deployments struct {
	// An object relationship
	App                 *Apps      `json:"app"`
	AppID               string     `json:"appId"`
	CommitMessage       *string    `json:"commitMessage,omitempty"`
	CommitSha           string     `json:"commitSHA"`
	CommitUserAvatarURL *string    `json:"commitUserAvatarUrl,omitempty"`
	CommitUserName      *string    `json:"commitUserName,omitempty"`
	DeploymentEndedAt   *time.Time `json:"deploymentEndedAt,omitempty"`
	// An array relationship
	DeploymentLogs      []*DeploymentLogs `json:"deploymentLogs"`
	DeploymentStartedAt *time.Time        `json:"deploymentStartedAt,omitempty"`
	DeploymentStatus    *string           `json:"deploymentStatus,omitempty"`
	FunctionsEndedAt    *time.Time        `json:"functionsEndedAt,omitempty"`
	FunctionsStartedAt  *time.Time        `json:"functionsStartedAt,omitempty"`
	FunctionsStatus     *string           `json:"functionsStatus,omitempty"`
	ID                  string            `json:"id"`
	MetadataEndedAt     *time.Time        `json:"metadataEndedAt,omitempty"`
	MetadataStartedAt   *time.Time        `json:"metadataStartedAt,omitempty"`
	MetadataStatus      *string           `json:"metadataStatus,omitempty"`
	MigrationsEndedAt   *time.Time        `json:"migrationsEndedAt,omitempty"`
	MigrationsStartedAt *time.Time        `json:"migrationsStartedAt,omitempty"`
	MigrationsStatus    *string           `json:"migrationsStatus,omitempty"`
}

Table that keeps track of deployments done by watchtower

type DeploymentsAggregateOrderBy 

type DeploymentsAggregateOrderBy struct {
	Count *OrderBy               `json:"count,omitempty"`
	Max   *DeploymentsMaxOrderBy `json:"max,omitempty"`
	Min   *DeploymentsMinOrderBy `json:"min,omitempty"`
}

order by aggregate values of table "deployments"

type DeploymentsArrRelInsertInput 

type DeploymentsArrRelInsertInput struct {
	Data []*DeploymentsInsertInput `json:"data"`
	// upsert condition
	OnConflict *DeploymentsOnConflict `json:"on_conflict,omitempty"`
}

input type for inserting array relation for remote table "deployments"

type DeploymentsBoolExp 

type DeploymentsBoolExp struct {
	And                 []*DeploymentsBoolExp     `json:"_and,omitempty"`
	Not                 *DeploymentsBoolExp       `json:"_not,omitempty"`
	Or                  []*DeploymentsBoolExp     `json:"_or,omitempty"`
	App                 *AppsBoolExp              `json:"app,omitempty"`
	AppID               *UUIDComparisonExp        `json:"appId,omitempty"`
	CommitMessage       *StringComparisonExp      `json:"commitMessage,omitempty"`
	CommitSha           *StringComparisonExp      `json:"commitSHA,omitempty"`
	CommitUserAvatarURL *StringComparisonExp      `json:"commitUserAvatarUrl,omitempty"`
	CommitUserName      *StringComparisonExp      `json:"commitUserName,omitempty"`
	DeploymentEndedAt   *TimestamptzComparisonExp `json:"deploymentEndedAt,omitempty"`
	DeploymentLogs      *DeploymentLogsBoolExp    `json:"deploymentLogs,omitempty"`
	DeploymentStartedAt *TimestamptzComparisonExp `json:"deploymentStartedAt,omitempty"`
	DeploymentStatus    *StringComparisonExp      `json:"deploymentStatus,omitempty"`
	FunctionsEndedAt    *TimestamptzComparisonExp `json:"functionsEndedAt,omitempty"`
	FunctionsStartedAt  *TimestamptzComparisonExp `json:"functionsStartedAt,omitempty"`
	FunctionsStatus     *StringComparisonExp      `json:"functionsStatus,omitempty"`
	ID                  *UUIDComparisonExp        `json:"id,omitempty"`
	MetadataEndedAt     *TimestamptzComparisonExp `json:"metadataEndedAt,omitempty"`
	MetadataStartedAt   *TimestamptzComparisonExp `json:"metadataStartedAt,omitempty"`
	MetadataStatus      *StringComparisonExp      `json:"metadataStatus,omitempty"`
	MigrationsEndedAt   *TimestamptzComparisonExp `json:"migrationsEndedAt,omitempty"`
	MigrationsStartedAt *TimestamptzComparisonExp `json:"migrationsStartedAt,omitempty"`
	MigrationsStatus    *StringComparisonExp      `json:"migrationsStatus,omitempty"`
}

Boolean expression to filter rows from the table "deployments". All fields are combined with a logical 'AND'.

type DeploymentsConstraint 

type DeploymentsConstraint string

unique or primary key constraints on table "deployments" 

const (
	// unique or primary key constraint on columns "id"
	DeploymentsConstraintDeploymentsPkey DeploymentsConstraint = "deployments_pkey"
)

func (DeploymentsConstraint) IsValid 

func (e DeploymentsConstraint) IsValid() bool

func (DeploymentsConstraint) MarshalGQL 

func (e DeploymentsConstraint) MarshalGQL(w io.Writer)

func (DeploymentsConstraint) String 

func (e DeploymentsConstraint) String() string

func (*DeploymentsConstraint) UnmarshalGQL 

func (e *DeploymentsConstraint) UnmarshalGQL(v interface{}) error

type DeploymentsInsertInput 

type DeploymentsInsertInput struct {
	App                 *AppsObjRelInsertInput `json:"app,omitempty"`
	AppID               *string                `json:"appId,omitempty"`
	CommitMessage       *string                `json:"commitMessage,omitempty"`
	CommitSha           *string                `json:"commitSHA,omitempty"`
	CommitUserAvatarURL *string                `json:"commitUserAvatarUrl,omitempty"`
	CommitUserName      *string                `json:"commitUserName,omitempty"`
	DeploymentStatus    *string                `json:"deploymentStatus,omitempty"`
}

input type for inserting data into table "deployments"

type DeploymentsMaxOrderBy 

type DeploymentsMaxOrderBy struct {
	AppID               *OrderBy `json:"appId,omitempty"`
	CommitMessage       *OrderBy `json:"commitMessage,omitempty"`
	CommitSha           *OrderBy `json:"commitSHA,omitempty"`
	CommitUserAvatarURL *OrderBy `json:"commitUserAvatarUrl,omitempty"`
	CommitUserName      *OrderBy `json:"commitUserName,omitempty"`
	DeploymentEndedAt   *OrderBy `json:"deploymentEndedAt,omitempty"`
	DeploymentStartedAt *OrderBy `json:"deploymentStartedAt,omitempty"`
	DeploymentStatus    *OrderBy `json:"deploymentStatus,omitempty"`
	FunctionsEndedAt    *OrderBy `json:"functionsEndedAt,omitempty"`
	FunctionsStartedAt  *OrderBy `json:"functionsStartedAt,omitempty"`
	FunctionsStatus     *OrderBy `json:"functionsStatus,omitempty"`
	ID                  *OrderBy `json:"id,omitempty"`
	MetadataEndedAt     *OrderBy `json:"metadataEndedAt,omitempty"`
	MetadataStartedAt   *OrderBy `json:"metadataStartedAt,omitempty"`
	MetadataStatus      *OrderBy `json:"metadataStatus,omitempty"`
	MigrationsEndedAt   *OrderBy `json:"migrationsEndedAt,omitempty"`
	MigrationsStartedAt *OrderBy `json:"migrationsStartedAt,omitempty"`
	MigrationsStatus    *OrderBy `json:"migrationsStatus,omitempty"`
}

order by max() on columns of table "deployments"

type DeploymentsMinOrderBy 

type DeploymentsMinOrderBy struct {
	AppID               *OrderBy `json:"appId,omitempty"`
	CommitMessage       *OrderBy `json:"commitMessage,omitempty"`
	CommitSha           *OrderBy `json:"commitSHA,omitempty"`
	CommitUserAvatarURL *OrderBy `json:"commitUserAvatarUrl,omitempty"`
	CommitUserName      *OrderBy `json:"commitUserName,omitempty"`
	DeploymentEndedAt   *OrderBy `json:"deploymentEndedAt,omitempty"`
	DeploymentStartedAt *OrderBy `json:"deploymentStartedAt,omitempty"`
	DeploymentStatus    *OrderBy `json:"deploymentStatus,omitempty"`
	FunctionsEndedAt    *OrderBy `json:"functionsEndedAt,omitempty"`
	FunctionsStartedAt  *OrderBy `json:"functionsStartedAt,omitempty"`
	FunctionsStatus     *OrderBy `json:"functionsStatus,omitempty"`
	ID                  *OrderBy `json:"id,omitempty"`
	MetadataEndedAt     *OrderBy `json:"metadataEndedAt,omitempty"`
	MetadataStartedAt   *OrderBy `json:"metadataStartedAt,omitempty"`
	MetadataStatus      *OrderBy `json:"metadataStatus,omitempty"`
	MigrationsEndedAt   *OrderBy `json:"migrationsEndedAt,omitempty"`
	MigrationsStartedAt *OrderBy `json:"migrationsStartedAt,omitempty"`
	MigrationsStatus    *OrderBy `json:"migrationsStatus,omitempty"`
}

order by min() on columns of table "deployments"

type DeploymentsMutationResponse 

type DeploymentsMutationResponse struct {
	// number of rows affected by the mutation
	AffectedRows int64 `json:"affected_rows"`
	// data from the rows affected by the mutation
	Returning []*Deployments `json:"returning"`
}

response of any mutation on the table "deployments"

type DeploymentsOnConflict 

type DeploymentsOnConflict struct {
	Constraint    DeploymentsConstraint     `json:"constraint"`
	UpdateColumns []DeploymentsUpdateColumn `json:"update_columns"`
	Where         *DeploymentsBoolExp       `json:"where,omitempty"`
}

on_conflict condition type for table "deployments"

type DeploymentsOrderBy 

type DeploymentsOrderBy struct {
	App                     *AppsOrderBy                    `json:"app,omitempty"`
	AppID                   *OrderBy                        `json:"appId,omitempty"`
	CommitMessage           *OrderBy                        `json:"commitMessage,omitempty"`
	CommitSha               *OrderBy                        `json:"commitSHA,omitempty"`
	CommitUserAvatarURL     *OrderBy                        `json:"commitUserAvatarUrl,omitempty"`
	CommitUserName          *OrderBy                        `json:"commitUserName,omitempty"`
	DeploymentEndedAt       *OrderBy                        `json:"deploymentEndedAt,omitempty"`
	DeploymentLogsAggregate *DeploymentLogsAggregateOrderBy `json:"deploymentLogs_aggregate,omitempty"`
	DeploymentStartedAt     *OrderBy                        `json:"deploymentStartedAt,omitempty"`
	DeploymentStatus        *OrderBy                        `json:"deploymentStatus,omitempty"`
	FunctionsEndedAt        *OrderBy                        `json:"functionsEndedAt,omitempty"`
	FunctionsStartedAt      *OrderBy                        `json:"functionsStartedAt,omitempty"`
	FunctionsStatus         *OrderBy                        `json:"functionsStatus,omitempty"`
	ID                      *OrderBy                        `json:"id,omitempty"`
	MetadataEndedAt         *OrderBy                        `json:"metadataEndedAt,omitempty"`
	MetadataStartedAt       *OrderBy                        `json:"metadataStartedAt,omitempty"`
	MetadataStatus          *OrderBy                        `json:"metadataStatus,omitempty"`
	MigrationsEndedAt       *OrderBy                        `json:"migrationsEndedAt,omitempty"`
	MigrationsStartedAt     *OrderBy                        `json:"migrationsStartedAt,omitempty"`
	MigrationsStatus        *OrderBy                        `json:"migrationsStatus,omitempty"`
}

Ordering options when selecting data from "deployments".

type DeploymentsSelectColumn 

type DeploymentsSelectColumn string

select columns of table "deployments" 

const (
	// column name
	DeploymentsSelectColumnAppID DeploymentsSelectColumn = "appId"
	// column name
	DeploymentsSelectColumnCommitMessage DeploymentsSelectColumn = "commitMessage"
	// column name
	DeploymentsSelectColumnCommitSha DeploymentsSelectColumn = "commitSHA"
	// column name
	DeploymentsSelectColumnCommitUserAvatarURL DeploymentsSelectColumn = "commitUserAvatarUrl"
	// column name
	DeploymentsSelectColumnCommitUserName DeploymentsSelectColumn = "commitUserName"
	// column name
	DeploymentsSelectColumnDeploymentEndedAt DeploymentsSelectColumn = "deploymentEndedAt"
	// column name
	DeploymentsSelectColumnDeploymentStartedAt DeploymentsSelectColumn = "deploymentStartedAt"
	// column name
	DeploymentsSelectColumnDeploymentStatus DeploymentsSelectColumn = "deploymentStatus"
	// column name
	DeploymentsSelectColumnFunctionsEndedAt DeploymentsSelectColumn = "functionsEndedAt"
	// column name
	DeploymentsSelectColumnFunctionsStartedAt DeploymentsSelectColumn = "functionsStartedAt"
	// column name
	DeploymentsSelectColumnFunctionsStatus DeploymentsSelectColumn = "functionsStatus"
	// column name
	DeploymentsSelectColumnID DeploymentsSelectColumn = "id"
	// column name
	DeploymentsSelectColumnMetadataEndedAt DeploymentsSelectColumn = "metadataEndedAt"
	// column name
	DeploymentsSelectColumnMetadataStartedAt DeploymentsSelectColumn = "metadataStartedAt"
	// column name
	DeploymentsSelectColumnMetadataStatus DeploymentsSelectColumn = "metadataStatus"
	// column name
	DeploymentsSelectColumnMigrationsEndedAt DeploymentsSelectColumn = "migrationsEndedAt"
	// column name
	DeploymentsSelectColumnMigrationsStartedAt DeploymentsSelectColumn = "migrationsStartedAt"
	// column name
	DeploymentsSelectColumnMigrationsStatus DeploymentsSelectColumn = "migrationsStatus"
)

func (DeploymentsSelectColumn) IsValid 

func (e DeploymentsSelectColumn) IsValid() bool

func (DeploymentsSelectColumn) MarshalGQL 

func (e DeploymentsSelectColumn) MarshalGQL(w io.Writer)

func (DeploymentsSelectColumn) String 

func (e DeploymentsSelectColumn) String() string

func (*DeploymentsSelectColumn) UnmarshalGQL 

func (e *DeploymentsSelectColumn) UnmarshalGQL(v interface{}) error

type DeploymentsStreamCursorInput 

type DeploymentsStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *DeploymentsStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "deployments"

type DeploymentsStreamCursorValueInput 

type DeploymentsStreamCursorValueInput struct {
	AppID               *string    `json:"appId,omitempty"`
	CommitMessage       *string    `json:"commitMessage,omitempty"`
	CommitSha           *string    `json:"commitSHA,omitempty"`
	CommitUserAvatarURL *string    `json:"commitUserAvatarUrl,omitempty"`
	CommitUserName      *string    `json:"commitUserName,omitempty"`
	DeploymentEndedAt   *time.Time `json:"deploymentEndedAt,omitempty"`
	DeploymentStartedAt *time.Time `json:"deploymentStartedAt,omitempty"`
	DeploymentStatus    *string    `json:"deploymentStatus,omitempty"`
	FunctionsEndedAt    *time.Time `json:"functionsEndedAt,omitempty"`
	FunctionsStartedAt  *time.Time `json:"functionsStartedAt,omitempty"`
	FunctionsStatus     *string    `json:"functionsStatus,omitempty"`
	ID                  *string    `json:"id,omitempty"`
	MetadataEndedAt     *time.Time `json:"metadataEndedAt,omitempty"`
	MetadataStartedAt   *time.Time `json:"metadataStartedAt,omitempty"`
	MetadataStatus      *string    `json:"metadataStatus,omitempty"`
	MigrationsEndedAt   *time.Time `json:"migrationsEndedAt,omitempty"`
	MigrationsStartedAt *time.Time `json:"migrationsStartedAt,omitempty"`
	MigrationsStatus    *string    `json:"migrationsStatus,omitempty"`
}

Initial value of the column from where the streaming should start

type DeploymentsUpdateColumn 

type DeploymentsUpdateColumn string

placeholder for update columns of table "deployments" (current role has no relevant permissions) 

const (
	// placeholder (do not use)
	DeploymentsUpdateColumnPlaceholder DeploymentsUpdateColumn = "_PLACEHOLDER"
)

func (DeploymentsUpdateColumn) IsValid 

func (e DeploymentsUpdateColumn) IsValid() bool

func (DeploymentsUpdateColumn) MarshalGQL 

func (e DeploymentsUpdateColumn) MarshalGQL(w io.Writer)

func (DeploymentsUpdateColumn) String 

func (e DeploymentsUpdateColumn) String() string

func (*DeploymentsUpdateColumn) UnmarshalGQL 

func (e *DeploymentsUpdateColumn) UnmarshalGQL(v interface{}) error

type FeatureFlags 

type FeatureFlags struct {
	// An object relationship
	App         *Apps  `json:"app"`
	AppID       string `json:"appId"`
	Description string `json:"description"`
	ID          string `json:"id"`
	Name        string `json:"name"`
	Value       string `json:"value"`
}

columns and relationships of "feature_flags"

type FeatureFlagsAggregateOrderBy 

type FeatureFlagsAggregateOrderBy struct {
	Count *OrderBy                `json:"count,omitempty"`
	Max   *FeatureFlagsMaxOrderBy `json:"max,omitempty"`
	Min   *FeatureFlagsMinOrderBy `json:"min,omitempty"`
}

order by aggregate values of table "feature_flags"

type FeatureFlagsArrRelInsertInput 

type FeatureFlagsArrRelInsertInput struct {
	Data []*FeatureFlagsInsertInput `json:"data"`
	// upsert condition
	OnConflict *FeatureFlagsOnConflict `json:"on_conflict,omitempty"`
}

input type for inserting array relation for remote table "feature_flags"

type FeatureFlagsBoolExp 

type FeatureFlagsBoolExp struct {
	And         []*FeatureFlagsBoolExp `json:"_and,omitempty"`
	Not         *FeatureFlagsBoolExp   `json:"_not,omitempty"`
	Or          []*FeatureFlagsBoolExp `json:"_or,omitempty"`
	App         *AppsBoolExp           `json:"app,omitempty"`
	AppID       *UUIDComparisonExp     `json:"appId,omitempty"`
	Description *StringComparisonExp   `json:"description,omitempty"`
	ID          *UUIDComparisonExp     `json:"id,omitempty"`
	Name        *StringComparisonExp   `json:"name,omitempty"`
	Value       *StringComparisonExp   `json:"value,omitempty"`
}

Boolean expression to filter rows from the table "feature_flags". All fields are combined with a logical 'AND'.

type FeatureFlagsConstraint 

type FeatureFlagsConstraint string

unique or primary key constraints on table "feature_flags" 

const (
	// unique or primary key constraint on columns "id"
	FeatureFlagsConstraintFeatureFlagsPkey FeatureFlagsConstraint = "feature_flags_pkey"
)

func (FeatureFlagsConstraint) IsValid 

func (e FeatureFlagsConstraint) IsValid() bool

func (FeatureFlagsConstraint) MarshalGQL 

func (e FeatureFlagsConstraint) MarshalGQL(w io.Writer)

func (FeatureFlagsConstraint) String 

func (e FeatureFlagsConstraint) String() string

func (*FeatureFlagsConstraint) UnmarshalGQL 

func (e *FeatureFlagsConstraint) UnmarshalGQL(v interface{}) error

type FeatureFlagsInsertInput 

type FeatureFlagsInsertInput struct {
	App         *AppsObjRelInsertInput `json:"app,omitempty"`
	AppID       *string                `json:"appId,omitempty"`
	Description *string                `json:"description,omitempty"`
	Name        *string                `json:"name,omitempty"`
	Value       *string                `json:"value,omitempty"`
}

input type for inserting data into table "feature_flags"

type FeatureFlagsMaxOrderBy 

type FeatureFlagsMaxOrderBy struct {
	AppID       *OrderBy `json:"appId,omitempty"`
	Description *OrderBy `json:"description,omitempty"`
	ID          *OrderBy `json:"id,omitempty"`
	Name        *OrderBy `json:"name,omitempty"`
	Value       *OrderBy `json:"value,omitempty"`
}

order by max() on columns of table "feature_flags"

type FeatureFlagsMinOrderBy 

type FeatureFlagsMinOrderBy struct {
	AppID       *OrderBy `json:"appId,omitempty"`
	Description *OrderBy `json:"description,omitempty"`
	ID          *OrderBy `json:"id,omitempty"`
	Name        *OrderBy `json:"name,omitempty"`
	Value       *OrderBy `json:"value,omitempty"`
}

order by min() on columns of table "feature_flags"

type FeatureFlagsMutationResponse 

type FeatureFlagsMutationResponse struct {
	// number of rows affected by the mutation
	AffectedRows int64 `json:"affected_rows"`
	// data from the rows affected by the mutation
	Returning []*FeatureFlags `json:"returning"`
}

response of any mutation on the table "feature_flags"

type FeatureFlagsOnConflict 

type FeatureFlagsOnConflict struct {
	Constraint    FeatureFlagsConstraint     `json:"constraint"`
	UpdateColumns []FeatureFlagsUpdateColumn `json:"update_columns"`
	Where         *FeatureFlagsBoolExp       `json:"where,omitempty"`
}

on_conflict condition type for table "feature_flags"

type FeatureFlagsOrderBy 

type FeatureFlagsOrderBy struct {
	App         *AppsOrderBy `json:"app,omitempty"`
	AppID       *OrderBy     `json:"appId,omitempty"`
	Description *OrderBy     `json:"description,omitempty"`
	ID          *OrderBy     `json:"id,omitempty"`
	Name        *OrderBy     `json:"name,omitempty"`
	Value       *OrderBy     `json:"value,omitempty"`
}

Ordering options when selecting data from "feature_flags".

type FeatureFlagsSelectColumn 

type FeatureFlagsSelectColumn string

select columns of table "feature_flags" 

const (
	// column name
	FeatureFlagsSelectColumnAppID FeatureFlagsSelectColumn = "appId"
	// column name
	FeatureFlagsSelectColumnDescription FeatureFlagsSelectColumn = "description"
	// column name
	FeatureFlagsSelectColumnID FeatureFlagsSelectColumn = "id"
	// column name
	FeatureFlagsSelectColumnName FeatureFlagsSelectColumn = "name"
	// column name
	FeatureFlagsSelectColumnValue FeatureFlagsSelectColumn = "value"
)

func (FeatureFlagsSelectColumn) IsValid 

func (e FeatureFlagsSelectColumn) IsValid() bool

func (FeatureFlagsSelectColumn) MarshalGQL 

func (e FeatureFlagsSelectColumn) MarshalGQL(w io.Writer)

func (FeatureFlagsSelectColumn) String 

func (e FeatureFlagsSelectColumn) String() string

func (*FeatureFlagsSelectColumn) UnmarshalGQL 

func (e *FeatureFlagsSelectColumn) UnmarshalGQL(v interface{}) error

type FeatureFlagsStreamCursorInput 

type FeatureFlagsStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *FeatureFlagsStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "featureFlags"

type FeatureFlagsStreamCursorValueInput 

type FeatureFlagsStreamCursorValueInput struct {
	AppID       *string `json:"appId,omitempty"`
	Description *string `json:"description,omitempty"`
	ID          *string `json:"id,omitempty"`
	Name        *string `json:"name,omitempty"`
	Value       *string `json:"value,omitempty"`
}

Initial value of the column from where the streaming should start

type FeatureFlagsUpdateColumn 

type FeatureFlagsUpdateColumn string

placeholder for update columns of table "feature_flags" (current role has no relevant permissions) 

const (
	// placeholder (do not use)
	FeatureFlagsUpdateColumnPlaceholder FeatureFlagsUpdateColumn = "_PLACEHOLDER"
)

func (FeatureFlagsUpdateColumn) IsValid 

func (e FeatureFlagsUpdateColumn) IsValid() bool

func (FeatureFlagsUpdateColumn) MarshalGQL 

func (e FeatureFlagsUpdateColumn) MarshalGQL(w io.Writer)

func (FeatureFlagsUpdateColumn) String 

func (e FeatureFlagsUpdateColumn) String() string

func (*FeatureFlagsUpdateColumn) UnmarshalGQL 

func (e *FeatureFlagsUpdateColumn) UnmarshalGQL(v interface{}) error

type GetConfigRawJSON 

type GetConfigRawJSON struct {
	ConfigRawJSON string "json:\"configRawJSON\" graphql:\"configRawJSON\""
}

func (*GetConfigRawJSON) GetConfigRawJSON 

func (t *GetConfigRawJSON) GetConfigRawJSON() string

type GetHasuraAdminSecret 

type GetHasuraAdminSecret struct {
	App *GetHasuraAdminSecret_App "json:\"app,omitempty\" graphql:\"app\""
}

func (*GetHasuraAdminSecret) GetApp 

func (t *GetHasuraAdminSecret) GetApp() *GetHasuraAdminSecret_App

type GetHasuraAdminSecret_App 

type GetHasuraAdminSecret_App struct {
	Config *GetHasuraAdminSecret_App_Config "json:\"config,omitempty\" graphql:\"config\""
}

func (*GetHasuraAdminSecret_App) GetConfig 

func (t *GetHasuraAdminSecret_App) GetConfig() *GetHasuraAdminSecret_App_Config

type GetHasuraAdminSecret_App_Config 

type GetHasuraAdminSecret_App_Config struct {
	Hasura GetHasuraAdminSecret_App_Config_Hasura "json:\"hasura\" graphql:\"hasura\""
}

func (*GetHasuraAdminSecret_App_Config) GetHasura 

func (t *GetHasuraAdminSecret_App_Config) GetHasura() *GetHasuraAdminSecret_App_Config_Hasura

type GetHasuraAdminSecret_App_Config_Hasura 

type GetHasuraAdminSecret_App_Config_Hasura struct {
	Version     *string "json:\"version,omitempty\" graphql:\"version\""
	AdminSecret string  "json:\"adminSecret\" graphql:\"adminSecret\""
}

func (*GetHasuraAdminSecret_App_Config_Hasura) GetAdminSecret 

func (t *GetHasuraAdminSecret_App_Config_Hasura) GetAdminSecret() string

func (*GetHasuraAdminSecret_App_Config_Hasura) GetVersion 

func (t *GetHasuraAdminSecret_App_Config_Hasura) GetVersion() *string

type GetRunServiceConfigRawJSON added in v1.5.0 

type GetRunServiceConfigRawJSON struct {
	RunServiceConfigRawJSON string "json:\"runServiceConfigRawJSON\" graphql:\"runServiceConfigRawJSON\""
}

func (*GetRunServiceConfigRawJSON) GetRunServiceConfigRawJSON added in v1.5.0 

func (t *GetRunServiceConfigRawJSON) GetRunServiceConfigRawJSON() string

type GetRunServiceInfo added in v1.5.0 

type GetRunServiceInfo struct {
	RunService *GetRunServiceInfo_RunService "json:\"runService,omitempty\" graphql:\"runService\""
}

func (*GetRunServiceInfo) GetRunService added in v1.5.0 

func (t *GetRunServiceInfo) GetRunService() *GetRunServiceInfo_RunService

type GetRunServiceInfo_RunService added in v1.5.0 

type GetRunServiceInfo_RunService struct {
	AppID string "json:\"appID\" graphql:\"appID\""
}

func (*GetRunServiceInfo_RunService) GetAppID added in v1.5.0 

func (t *GetRunServiceInfo_RunService) GetAppID() string

type GetSecrets 

type GetSecrets struct {
	AppSecrets []*GetSecrets_AppSecrets "json:\"appSecrets\" graphql:\"appSecrets\""
}

func (*GetSecrets) GetAppSecrets 

func (t *GetSecrets) GetAppSecrets() []*GetSecrets_AppSecrets

type GetSecrets_AppSecrets 

type GetSecrets_AppSecrets struct {
	Name  string "json:\"name\" graphql:\"name\""
	Value string "json:\"value\" graphql:\"value\""
}

func (*GetSecrets_AppSecrets) GetName 

func (t *GetSecrets_AppSecrets) GetName() string

func (*GetSecrets_AppSecrets) GetValue 

func (t *GetSecrets_AppSecrets) GetValue() string

type GetSoftwareVersions added in v1.17.0 

type GetSoftwareVersions struct {
	SoftwareVersions []*GetSoftwareVersions_SoftwareVersions "json:\"softwareVersions\" graphql:\"softwareVersions\""
}

func (*GetSoftwareVersions) GetSoftwareVersions added in v1.17.0 

func (t *GetSoftwareVersions) GetSoftwareVersions() []*GetSoftwareVersions_SoftwareVersions

type GetSoftwareVersions_SoftwareVersions added in v1.17.0 

type GetSoftwareVersions_SoftwareVersions struct {
	Software SoftwareTypeEnum "json:\"software\" graphql:\"software\""
	Version  string           "json:\"version\" graphql:\"version\""
}

func (*GetSoftwareVersions_SoftwareVersions) GetSoftware added in v1.17.0 

func (t *GetSoftwareVersions_SoftwareVersions) GetSoftware() *SoftwareTypeEnum

func (*GetSoftwareVersions_SoftwareVersions) GetVersion added in v1.17.0 

func (t *GetSoftwareVersions_SoftwareVersions) GetVersion() string

type GetWorkspacesApps 

type GetWorkspacesApps struct {
	Workspaces []*GetWorkspacesApps_Workspaces "json:\"workspaces\" graphql:\"workspaces\""
}

func (*GetWorkspacesApps) GetWorkspaces 

func (t *GetWorkspacesApps) GetWorkspaces() []*GetWorkspacesApps_Workspaces

type GetWorkspacesApps_Workspaces 

type GetWorkspacesApps_Workspaces struct {
	Name string                               "json:\"name\" graphql:\"name\""
	Apps []*GetWorkspacesApps_Workspaces_Apps "json:\"apps\" graphql:\"apps\""
}

func (*GetWorkspacesApps_Workspaces) GetApps 

func (t *GetWorkspacesApps_Workspaces) GetApps() []*GetWorkspacesApps_Workspaces_Apps

func (*GetWorkspacesApps_Workspaces) GetName 

func (t *GetWorkspacesApps_Workspaces) GetName() string

type GetWorkspacesApps_Workspaces_Apps 

type GetWorkspacesApps_Workspaces_Apps struct {
	ID        string                                   "json:\"id\" graphql:\"id\""
	Name      string                                   "json:\"name\" graphql:\"name\""
	Subdomain string                                   "json:\"subdomain\" graphql:\"subdomain\""
	Region    GetWorkspacesApps_Workspaces_Apps_Region "json:\"region\" graphql:\"region\""
}

func (*GetWorkspacesApps_Workspaces_Apps) GetID 

func (t *GetWorkspacesApps_Workspaces_Apps) GetID() string

func (*GetWorkspacesApps_Workspaces_Apps) GetName 

func (t *GetWorkspacesApps_Workspaces_Apps) GetName() string

func (*GetWorkspacesApps_Workspaces_Apps) GetRegion 

func (t *GetWorkspacesApps_Workspaces_Apps) GetRegion() *GetWorkspacesApps_Workspaces_Apps_Region

func (*GetWorkspacesApps_Workspaces_Apps) GetSubdomain 

func (t *GetWorkspacesApps_Workspaces_Apps) GetSubdomain() string

type GetWorkspacesApps_Workspaces_Apps_Region 

type GetWorkspacesApps_Workspaces_Apps_Region struct {
	Name string "json:\"name\" graphql:\"name\""
}

func (*GetWorkspacesApps_Workspaces_Apps_Region) GetName added in v1.18.1 

func (t *GetWorkspacesApps_Workspaces_Apps_Region) GetName() string

type GithubAppInstallations 

type GithubAppInstallations struct {
	AccountAvatarURL *string   `json:"accountAvatarUrl,omitempty"`
	AccountLogin     *string   `json:"accountLogin,omitempty"`
	AccountType      *string   `json:"accountType,omitempty"`
	CreatedAt        time.Time `json:"createdAt"`
	// An array relationship
	GithubRepositories []*GithubRepositories `json:"githubRepositories"`
	ID                 string                `json:"id"`
	UpdatedAt          time.Time             `json:"updatedAt"`
	// An object relationship
	User *Users `json:"user,omitempty"`
}

columns and relationships of "github_app_installations"

type GithubAppInstallationsAggregateOrderBy 

type GithubAppInstallationsAggregateOrderBy struct {
	Count *OrderBy                          `json:"count,omitempty"`
	Max   *GithubAppInstallationsMaxOrderBy `json:"max,omitempty"`
	Min   *GithubAppInstallationsMinOrderBy `json:"min,omitempty"`
}

order by aggregate values of table "github_app_installations"

type GithubAppInstallationsBoolExp 

type GithubAppInstallationsBoolExp struct {
	And                []*GithubAppInstallationsBoolExp `json:"_and,omitempty"`
	Not                *GithubAppInstallationsBoolExp   `json:"_not,omitempty"`
	Or                 []*GithubAppInstallationsBoolExp `json:"_or,omitempty"`
	AccountAvatarURL   *StringComparisonExp             `json:"accountAvatarUrl,omitempty"`
	AccountLogin       *StringComparisonExp             `json:"accountLogin,omitempty"`
	AccountType        *StringComparisonExp             `json:"accountType,omitempty"`
	CreatedAt          *TimestamptzComparisonExp        `json:"createdAt,omitempty"`
	GithubRepositories *GithubRepositoriesBoolExp       `json:"githubRepositories,omitempty"`
	ID                 *UUIDComparisonExp               `json:"id,omitempty"`
	UpdatedAt          *TimestamptzComparisonExp        `json:"updatedAt,omitempty"`
	User               *UsersBoolExp                    `json:"user,omitempty"`
}

Boolean expression to filter rows from the table "github_app_installations". All fields are combined with a logical 'AND'.

type GithubAppInstallationsConstraint 

type GithubAppInstallationsConstraint string

unique or primary key constraints on table "github_app_installations" 

const (
	// unique or primary key constraint on columns "external_github_app_installation_id"
	GithubAppInstallationsConstraintGithubAppInstallationsExternalGithubAppInstallationIKey GithubAppInstallationsConstraint = "github_app_installations_external_github_app_installation_i_key"
	// unique or primary key constraint on columns "id"
	GithubAppInstallationsConstraintGithubAppInstallationsPkey GithubAppInstallationsConstraint = "github_app_installations_pkey"
)

func (GithubAppInstallationsConstraint) IsValid 

func (e GithubAppInstallationsConstraint) IsValid() bool

func (GithubAppInstallationsConstraint) MarshalGQL 

func (e GithubAppInstallationsConstraint) MarshalGQL(w io.Writer)

func (GithubAppInstallationsConstraint) String 

func (e GithubAppInstallationsConstraint) String() string

func (*GithubAppInstallationsConstraint) UnmarshalGQL 

func (e *GithubAppInstallationsConstraint) UnmarshalGQL(v interface{}) error

type GithubAppInstallationsInsertInput 

type GithubAppInstallationsInsertInput struct {
	AccountAvatarURL                *string                `json:"accountAvatarUrl,omitempty"`
	AccountLogin                    *string                `json:"accountLogin,omitempty"`
	AccountNodeID                   *string                `json:"accountNodeId,omitempty"`
	AccountType                     *string                `json:"accountType,omitempty"`
	ExternalGithubAppInstallationID *int64                 `json:"externalGithubAppInstallationId,omitempty"`
	GithubData                      map[string]interface{} `json:"githubData,omitempty"`
	UserID                          *string                `json:"userId,omitempty"`
}

input type for inserting data into table "github_app_installations"

type GithubAppInstallationsMaxOrderBy 

type GithubAppInstallationsMaxOrderBy struct {
	AccountAvatarURL *OrderBy `json:"accountAvatarUrl,omitempty"`
	AccountLogin     *OrderBy `json:"accountLogin,omitempty"`
	AccountType      *OrderBy `json:"accountType,omitempty"`
	CreatedAt        *OrderBy `json:"createdAt,omitempty"`
	ID               *OrderBy `json:"id,omitempty"`
	UpdatedAt        *OrderBy `json:"updatedAt,omitempty"`
}

order by max() on columns of table "github_app_installations"

type GithubAppInstallationsMinOrderBy 

type GithubAppInstallationsMinOrderBy struct {
	AccountAvatarURL *OrderBy `json:"accountAvatarUrl,omitempty"`
	AccountLogin     *OrderBy `json:"accountLogin,omitempty"`
	AccountType      *OrderBy `json:"accountType,omitempty"`
	CreatedAt        *OrderBy `json:"createdAt,omitempty"`
	ID               *OrderBy `json:"id,omitempty"`
	UpdatedAt        *OrderBy `json:"updatedAt,omitempty"`
}

order by min() on columns of table "github_app_installations"

type GithubAppInstallationsMutationResponse 

type GithubAppInstallationsMutationResponse struct {
	// number of rows affected by the mutation
	AffectedRows int64 `json:"affected_rows"`
	// data from the rows affected by the mutation
	Returning []*GithubAppInstallations `json:"returning"`
}

response of any mutation on the table "github_app_installations"

type GithubAppInstallationsOnConflict 

type GithubAppInstallationsOnConflict struct {
	Constraint    GithubAppInstallationsConstraint     `json:"constraint"`
	UpdateColumns []GithubAppInstallationsUpdateColumn `json:"update_columns"`
	Where         *GithubAppInstallationsBoolExp       `json:"where,omitempty"`
}

on_conflict condition type for table "github_app_installations"

type GithubAppInstallationsOrderBy 

type GithubAppInstallationsOrderBy struct {
	AccountAvatarURL            *OrderBy                            `json:"accountAvatarUrl,omitempty"`
	AccountLogin                *OrderBy                            `json:"accountLogin,omitempty"`
	AccountType                 *OrderBy                            `json:"accountType,omitempty"`
	CreatedAt                   *OrderBy                            `json:"createdAt,omitempty"`
	GithubRepositoriesAggregate *GithubRepositoriesAggregateOrderBy `json:"githubRepositories_aggregate,omitempty"`
	ID                          *OrderBy                            `json:"id,omitempty"`
	UpdatedAt                   *OrderBy                            `json:"updatedAt,omitempty"`
	User                        *UsersOrderBy                       `json:"user,omitempty"`
}

Ordering options when selecting data from "github_app_installations".

type GithubAppInstallationsPkColumnsInput 

type GithubAppInstallationsPkColumnsInput struct {
	ID string `json:"id"`
}

primary key columns input for table: github_app_installations

type GithubAppInstallationsSelectColumn 

type GithubAppInstallationsSelectColumn string

select columns of table "github_app_installations" 

const (
	// column name
	GithubAppInstallationsSelectColumnAccountAvatarURL GithubAppInstallationsSelectColumn = "accountAvatarUrl"
	// column name
	GithubAppInstallationsSelectColumnAccountLogin GithubAppInstallationsSelectColumn = "accountLogin"
	// column name
	GithubAppInstallationsSelectColumnAccountType GithubAppInstallationsSelectColumn = "accountType"
	// column name
	GithubAppInstallationsSelectColumnCreatedAt GithubAppInstallationsSelectColumn = "createdAt"
	// column name
	GithubAppInstallationsSelectColumnID GithubAppInstallationsSelectColumn = "id"
	// column name
	GithubAppInstallationsSelectColumnUpdatedAt GithubAppInstallationsSelectColumn = "updatedAt"
)

func (GithubAppInstallationsSelectColumn) IsValid 

func (e GithubAppInstallationsSelectColumn) IsValid() bool

func (GithubAppInstallationsSelectColumn) MarshalGQL 

func (e GithubAppInstallationsSelectColumn) MarshalGQL(w io.Writer)

func (GithubAppInstallationsSelectColumn) String 

func (e GithubAppInstallationsSelectColumn) String() string

func (*GithubAppInstallationsSelectColumn) UnmarshalGQL 

func (e *GithubAppInstallationsSelectColumn) UnmarshalGQL(v interface{}) error

type GithubAppInstallationsStreamCursorInput 

type GithubAppInstallationsStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *GithubAppInstallationsStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "githubAppInstallations"

type GithubAppInstallationsStreamCursorValueInput 

type GithubAppInstallationsStreamCursorValueInput struct {
	AccountAvatarURL *string    `json:"accountAvatarUrl,omitempty"`
	AccountLogin     *string    `json:"accountLogin,omitempty"`
	AccountType      *string    `json:"accountType,omitempty"`
	CreatedAt        *time.Time `json:"createdAt,omitempty"`
	ID               *string    `json:"id,omitempty"`
	UpdatedAt        *time.Time `json:"updatedAt,omitempty"`
}

Initial value of the column from where the streaming should start

type GithubAppInstallationsUpdateColumn 

type GithubAppInstallationsUpdateColumn string

placeholder for update columns of table "github_app_installations" (current role has no relevant permissions) 

const (
	// placeholder (do not use)
	GithubAppInstallationsUpdateColumnPlaceholder GithubAppInstallationsUpdateColumn = "_PLACEHOLDER"
)

func (GithubAppInstallationsUpdateColumn) IsValid 

func (e GithubAppInstallationsUpdateColumn) IsValid() bool

func (GithubAppInstallationsUpdateColumn) MarshalGQL 

func (e GithubAppInstallationsUpdateColumn) MarshalGQL(w io.Writer)

func (GithubAppInstallationsUpdateColumn) String 

func (e GithubAppInstallationsUpdateColumn) String() string

func (*GithubAppInstallationsUpdateColumn) UnmarshalGQL 

func (e *GithubAppInstallationsUpdateColumn) UnmarshalGQL(v interface{}) error

type GithubAppInstallationsUpdates 

type GithubAppInstallationsUpdates struct {
	// filter the rows which have to be updated
	Where *GithubAppInstallationsBoolExp `json:"where"`
}

type GithubRepositories 

type GithubRepositories struct {
	// An array relationship
	Apps      []*Apps   `json:"apps"`
	CreatedAt time.Time `json:"createdAt"`
	FullName  string    `json:"fullName"`
	// An object relationship
	GithubAppInstallation *GithubAppInstallations `json:"githubAppInstallation"`
	ID                    string                  `json:"id"`
	Name                  string                  `json:"name"`
	Private               bool                    `json:"private"`
	UpdatedAt             time.Time               `json:"updatedAt"`
}

columns and relationships of "github_repositories"

type GithubRepositoriesAggregateOrderBy 

type GithubRepositoriesAggregateOrderBy struct {
	Count *OrderBy                      `json:"count,omitempty"`
	Max   *GithubRepositoriesMaxOrderBy `json:"max,omitempty"`
	Min   *GithubRepositoriesMinOrderBy `json:"min,omitempty"`
}

order by aggregate values of table "github_repositories"

type GithubRepositoriesBoolExp 

type GithubRepositoriesBoolExp struct {
	And                   []*GithubRepositoriesBoolExp   `json:"_and,omitempty"`
	Not                   *GithubRepositoriesBoolExp     `json:"_not,omitempty"`
	Or                    []*GithubRepositoriesBoolExp   `json:"_or,omitempty"`
	Apps                  *AppsBoolExp                   `json:"apps,omitempty"`
	CreatedAt             *TimestamptzComparisonExp      `json:"createdAt,omitempty"`
	FullName              *StringComparisonExp           `json:"fullName,omitempty"`
	GithubAppInstallation *GithubAppInstallationsBoolExp `json:"githubAppInstallation,omitempty"`
	ID                    *UUIDComparisonExp             `json:"id,omitempty"`
	Name                  *StringComparisonExp           `json:"name,omitempty"`
	Private               *BooleanComparisonExp          `json:"private,omitempty"`
	UpdatedAt             *TimestamptzComparisonExp      `json:"updatedAt,omitempty"`
}

Boolean expression to filter rows from the table "github_repositories". All fields are combined with a logical 'AND'.

type GithubRepositoriesMaxOrderBy 

type GithubRepositoriesMaxOrderBy struct {
	CreatedAt *OrderBy `json:"createdAt,omitempty"`
	FullName  *OrderBy `json:"fullName,omitempty"`
	ID        *OrderBy `json:"id,omitempty"`
	Name      *OrderBy `json:"name,omitempty"`
	UpdatedAt *OrderBy `json:"updatedAt,omitempty"`
}

order by max() on columns of table "github_repositories"

type GithubRepositoriesMinOrderBy 

type GithubRepositoriesMinOrderBy struct {
	CreatedAt *OrderBy `json:"createdAt,omitempty"`
	FullName  *OrderBy `json:"fullName,omitempty"`
	ID        *OrderBy `json:"id,omitempty"`
	Name      *OrderBy `json:"name,omitempty"`
	UpdatedAt *OrderBy `json:"updatedAt,omitempty"`
}

order by min() on columns of table "github_repositories"

type GithubRepositoriesOrderBy 

type GithubRepositoriesOrderBy struct {
	AppsAggregate         *AppsAggregateOrderBy          `json:"apps_aggregate,omitempty"`
	CreatedAt             *OrderBy                       `json:"createdAt,omitempty"`
	FullName              *OrderBy                       `json:"fullName,omitempty"`
	GithubAppInstallation *GithubAppInstallationsOrderBy `json:"githubAppInstallation,omitempty"`
	ID                    *OrderBy                       `json:"id,omitempty"`
	Name                  *OrderBy                       `json:"name,omitempty"`
	Private               *OrderBy                       `json:"private,omitempty"`
	UpdatedAt             *OrderBy                       `json:"updatedAt,omitempty"`
}

Ordering options when selecting data from "github_repositories".

type GithubRepositoriesSelectColumn 

type GithubRepositoriesSelectColumn string

select columns of table "github_repositories" 

const (
	// column name
	GithubRepositoriesSelectColumnCreatedAt GithubRepositoriesSelectColumn = "createdAt"
	// column name
	GithubRepositoriesSelectColumnFullName GithubRepositoriesSelectColumn = "fullName"
	// column name
	GithubRepositoriesSelectColumnID GithubRepositoriesSelectColumn = "id"
	// column name
	GithubRepositoriesSelectColumnName GithubRepositoriesSelectColumn = "name"
	// column name
	GithubRepositoriesSelectColumnPrivate GithubRepositoriesSelectColumn = "private"
	// column name
	GithubRepositoriesSelectColumnUpdatedAt GithubRepositoriesSelectColumn = "updatedAt"
)

func (GithubRepositoriesSelectColumn) IsValid 

func (e GithubRepositoriesSelectColumn) IsValid() bool

func (GithubRepositoriesSelectColumn) MarshalGQL 

func (e GithubRepositoriesSelectColumn) MarshalGQL(w io.Writer)

func (GithubRepositoriesSelectColumn) String 

func (e GithubRepositoriesSelectColumn) String() string

func (*GithubRepositoriesSelectColumn) UnmarshalGQL 

func (e *GithubRepositoriesSelectColumn) UnmarshalGQL(v interface{}) error

type GithubRepositoriesStreamCursorInput 

type GithubRepositoriesStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *GithubRepositoriesStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "githubRepositories"

type GithubRepositoriesStreamCursorValueInput 

type GithubRepositoriesStreamCursorValueInput struct {
	CreatedAt *time.Time `json:"createdAt,omitempty"`
	FullName  *string    `json:"fullName,omitempty"`
	ID        *string    `json:"id,omitempty"`
	Name      *string    `json:"name,omitempty"`
	Private   *bool      `json:"private,omitempty"`
	UpdatedAt *time.Time `json:"updatedAt,omitempty"`
}

Initial value of the column from where the streaming should start

type IntComparisonExp 

type IntComparisonExp struct {
	Eq     *int64  `json:"_eq,omitempty"`
	Gt     *int64  `json:"_gt,omitempty"`
	Gte    *int64  `json:"_gte,omitempty"`
	In     []int64 `json:"_in,omitempty"`
	IsNull *bool   `json:"_is_null,omitempty"`
	Lt     *int64  `json:"_lt,omitempty"`
	Lte    *int64  `json:"_lte,omitempty"`
	Neq    *int64  `json:"_neq,omitempty"`
	Nin    []int64 `json:"_nin,omitempty"`
}

Boolean expression to compare columns of type "Int". All fields are combined with logical 'AND'.

type InvoiceItem added in v1.9.3 

type InvoiceItem struct {
	Amount      string `json:"Amount"`
	Description string `json:"Description"`
}

type InvoiceSummary added in v1.9.3 

type InvoiceSummary struct {
	AmountDue string         `json:"AmountDue"`
	PeriodEnd string         `json:"PeriodEnd"`
	Items     []*InvoiceItem `json:"items"`
}

type JsonbCastExp 

type JsonbCastExp struct {
	String *StringComparisonExp `json:"String,omitempty"`
}

type JsonbComparisonExp 

type JsonbComparisonExp struct {
	Cast *JsonbCastExp `json:"_cast,omitempty"`
	// is the column contained in the given json value
	ContainedIn map[string]interface{} `json:"_contained_in,omitempty"`
	// does the column contain the given json value at the top level
	Contains map[string]interface{} `json:"_contains,omitempty"`
	Eq       map[string]interface{} `json:"_eq,omitempty"`
	Gt       map[string]interface{} `json:"_gt,omitempty"`
	Gte      map[string]interface{} `json:"_gte,omitempty"`
	// does the string exist as a top-level key in the column
	HasKey *string `json:"_has_key,omitempty"`
	// do all of these strings exist as top-level keys in the column
	HasKeysAll []string `json:"_has_keys_all,omitempty"`
	// do any of these strings exist as top-level keys in the column
	HasKeysAny []string                 `json:"_has_keys_any,omitempty"`
	In         []map[string]interface{} `json:"_in,omitempty"`
	IsNull     *bool                    `json:"_is_null,omitempty"`
	Lt         map[string]interface{}   `json:"_lt,omitempty"`
	Lte        map[string]interface{}   `json:"_lte,omitempty"`
	Neq        map[string]interface{}   `json:"_neq,omitempty"`
	Nin        []map[string]interface{} `json:"_nin,omitempty"`
}

Boolean expression to compare columns of type "jsonb". All fields are combined with logical 'AND'.

type LastError added in v1.18.1 

type LastError struct {
	ExitCode int64  `json:"exitCode"`
	Message  string `json:"message"`
	Reason   string `json:"reason"`
}

type Log 

type Log struct {
	Log       string `json:"log"`
	Service   string `json:"service"`
	Timestamp string `json:"timestamp"`
}

type Metrics 

type Metrics struct {
	Value string `json:"value"`
}

type MutationRoot 

type MutationRoot struct {
}

mutation root

type OrderBy 

type OrderBy string

column ordering options 

const (
	// in ascending order, nulls last
	OrderByAsc OrderBy = "asc"
	// in ascending order, nulls first
	OrderByAscNullsFirst OrderBy = "asc_nulls_first"
	// in ascending order, nulls last
	OrderByAscNullsLast OrderBy = "asc_nulls_last"
	// in descending order, nulls first
	OrderByDesc OrderBy = "desc"
	// in descending order, nulls first
	OrderByDescNullsFirst OrderBy = "desc_nulls_first"
	// in descending order, nulls last
	OrderByDescNullsLast OrderBy = "desc_nulls_last"
)

func (OrderBy) IsValid 

func (e OrderBy) IsValid() bool

func (OrderBy) MarshalGQL 

func (e OrderBy) MarshalGQL(w io.Writer)

func (OrderBy) String 

func (e OrderBy) String() string

func (*OrderBy) UnmarshalGQL 

func (e *OrderBy) UnmarshalGQL(v interface{}) error

type PaymentMethods 

type PaymentMethods struct {
	AddedByUserID         string    `json:"addedByUserId"`
	CardBrand             string    `json:"cardBrand"`
	CardExpMonth          int64     `json:"cardExpMonth"`
	CardExpYear           int64     `json:"cardExpYear"`
	CardLast4             string    `json:"cardLast4"`
	CreatedAt             time.Time `json:"createdAt"`
	ID                    string    `json:"id"`
	IsDefault             bool      `json:"isDefault"`
	StripePaymentMethodID string    `json:"stripePaymentMethodId"`
	// An object relationship
	User *Users `json:"user"`
	// An object relationship
	Workspace   *Workspaces `json:"workspace"`
	WorkspaceID string      `json:"workspaceId"`
}

columns and relationships of "payment_methods"

type PaymentMethodsAggregateOrderBy 

type PaymentMethodsAggregateOrderBy struct {
	Avg        *PaymentMethodsAvgOrderBy        `json:"avg,omitempty"`
	Count      *OrderBy                         `json:"count,omitempty"`
	Max        *PaymentMethodsMaxOrderBy        `json:"max,omitempty"`
	Min        *PaymentMethodsMinOrderBy        `json:"min,omitempty"`
	Stddev     *PaymentMethodsStddevOrderBy     `json:"stddev,omitempty"`
	StddevPop  *PaymentMethodsStddevPopOrderBy  `json:"stddev_pop,omitempty"`
	StddevSamp *PaymentMethodsStddevSampOrderBy `json:"stddev_samp,omitempty"`
	Sum        *PaymentMethodsSumOrderBy        `json:"sum,omitempty"`
	VarPop     *PaymentMethodsVarPopOrderBy     `json:"var_pop,omitempty"`
	VarSamp    *PaymentMethodsVarSampOrderBy    `json:"var_samp,omitempty"`
	Variance   *PaymentMethodsVarianceOrderBy   `json:"variance,omitempty"`
}

order by aggregate values of table "payment_methods"

type PaymentMethodsArrRelInsertInput 

type PaymentMethodsArrRelInsertInput struct {
	Data []*PaymentMethodsInsertInput `json:"data"`
	// upsert condition
	OnConflict *PaymentMethodsOnConflict `json:"on_conflict,omitempty"`
}

input type for inserting array relation for remote table "payment_methods"

type PaymentMethodsAvgOrderBy 

type PaymentMethodsAvgOrderBy struct {
	CardExpMonth *OrderBy `json:"cardExpMonth,omitempty"`
	CardExpYear  *OrderBy `json:"cardExpYear,omitempty"`
}

order by avg() on columns of table "payment_methods"

type PaymentMethodsBoolExp 

type PaymentMethodsBoolExp struct {
	And                   []*PaymentMethodsBoolExp  `json:"_and,omitempty"`
	Not                   *PaymentMethodsBoolExp    `json:"_not,omitempty"`
	Or                    []*PaymentMethodsBoolExp  `json:"_or,omitempty"`
	AddedByUserID         *UUIDComparisonExp        `json:"addedByUserId,omitempty"`
	CardBrand             *StringComparisonExp      `json:"cardBrand,omitempty"`
	CardExpMonth          *IntComparisonExp         `json:"cardExpMonth,omitempty"`
	CardExpYear           *IntComparisonExp         `json:"cardExpYear,omitempty"`
	CardLast4             *StringComparisonExp      `json:"cardLast4,omitempty"`
	CreatedAt             *TimestamptzComparisonExp `json:"createdAt,omitempty"`
	ID                    *UUIDComparisonExp        `json:"id,omitempty"`
	IsDefault             *BooleanComparisonExp     `json:"isDefault,omitempty"`
	StripePaymentMethodID *StringComparisonExp      `json:"stripePaymentMethodId,omitempty"`
	User                  *UsersBoolExp             `json:"user,omitempty"`
	Workspace             *WorkspacesBoolExp        `json:"workspace,omitempty"`
	WorkspaceID           *UUIDComparisonExp        `json:"workspaceId,omitempty"`
}

Boolean expression to filter rows from the table "payment_methods". All fields are combined with a logical 'AND'.

type PaymentMethodsConstraint 

type PaymentMethodsConstraint string

unique or primary key constraints on table "payment_methods" 

const (
	// unique or primary key constraint on columns "id"
	PaymentMethodsConstraintPaymentMethodsPkey PaymentMethodsConstraint = "payment_methods_pkey"
)

func (PaymentMethodsConstraint) IsValid 

func (e PaymentMethodsConstraint) IsValid() bool

func (PaymentMethodsConstraint) MarshalGQL 

func (e PaymentMethodsConstraint) MarshalGQL(w io.Writer)

func (PaymentMethodsConstraint) String 

func (e PaymentMethodsConstraint) String() string

func (*PaymentMethodsConstraint) UnmarshalGQL 

func (e *PaymentMethodsConstraint) UnmarshalGQL(v interface{}) error

type PaymentMethodsInsertInput 

type PaymentMethodsInsertInput struct {
	CardBrand             *string                      `json:"cardBrand,omitempty"`
	CardExpMonth          *int64                       `json:"cardExpMonth,omitempty"`
	CardExpYear           *int64                       `json:"cardExpYear,omitempty"`
	CardLast4             *string                      `json:"cardLast4,omitempty"`
	IsDefault             *bool                        `json:"isDefault,omitempty"`
	StripePaymentMethodID *string                      `json:"stripePaymentMethodId,omitempty"`
	Workspace             *WorkspacesObjRelInsertInput `json:"workspace,omitempty"`
	WorkspaceID           *string                      `json:"workspaceId,omitempty"`
}

input type for inserting data into table "payment_methods"

type PaymentMethodsMaxOrderBy 

type PaymentMethodsMaxOrderBy struct {
	AddedByUserID         *OrderBy `json:"addedByUserId,omitempty"`
	CardBrand             *OrderBy `json:"cardBrand,omitempty"`
	CardExpMonth          *OrderBy `json:"cardExpMonth,omitempty"`
	CardExpYear           *OrderBy `json:"cardExpYear,omitempty"`
	CardLast4             *OrderBy `json:"cardLast4,omitempty"`
	CreatedAt             *OrderBy `json:"createdAt,omitempty"`
	ID                    *OrderBy `json:"id,omitempty"`
	StripePaymentMethodID *OrderBy `json:"stripePaymentMethodId,omitempty"`
	WorkspaceID           *OrderBy `json:"workspaceId,omitempty"`
}

order by max() on columns of table "payment_methods"

type PaymentMethodsMinOrderBy 

type PaymentMethodsMinOrderBy struct {
	AddedByUserID         *OrderBy `json:"addedByUserId,omitempty"`
	CardBrand             *OrderBy `json:"cardBrand,omitempty"`
	CardExpMonth          *OrderBy `json:"cardExpMonth,omitempty"`
	CardExpYear           *OrderBy `json:"cardExpYear,omitempty"`
	CardLast4             *OrderBy `json:"cardLast4,omitempty"`
	CreatedAt             *OrderBy `json:"createdAt,omitempty"`
	ID                    *OrderBy `json:"id,omitempty"`
	StripePaymentMethodID *OrderBy `json:"stripePaymentMethodId,omitempty"`
	WorkspaceID           *OrderBy `json:"workspaceId,omitempty"`
}

order by min() on columns of table "payment_methods"

type PaymentMethodsMutationResponse 

type PaymentMethodsMutationResponse struct {
	// number of rows affected by the mutation
	AffectedRows int64 `json:"affected_rows"`
	// data from the rows affected by the mutation
	Returning []*PaymentMethods `json:"returning"`
}

response of any mutation on the table "payment_methods"

type PaymentMethodsObjRelInsertInput 

type PaymentMethodsObjRelInsertInput struct {
	Data *PaymentMethodsInsertInput `json:"data"`
	// upsert condition
	OnConflict *PaymentMethodsOnConflict `json:"on_conflict,omitempty"`
}

input type for inserting object relation for remote table "payment_methods"

type PaymentMethodsOnConflict 

type PaymentMethodsOnConflict struct {
	Constraint    PaymentMethodsConstraint     `json:"constraint"`
	UpdateColumns []PaymentMethodsUpdateColumn `json:"update_columns"`
	Where         *PaymentMethodsBoolExp       `json:"where,omitempty"`
}

on_conflict condition type for table "payment_methods"

type PaymentMethodsOrderBy 

type PaymentMethodsOrderBy struct {
	AddedByUserID         *OrderBy           `json:"addedByUserId,omitempty"`
	CardBrand             *OrderBy           `json:"cardBrand,omitempty"`
	CardExpMonth          *OrderBy           `json:"cardExpMonth,omitempty"`
	CardExpYear           *OrderBy           `json:"cardExpYear,omitempty"`
	CardLast4             *OrderBy           `json:"cardLast4,omitempty"`
	CreatedAt             *OrderBy           `json:"createdAt,omitempty"`
	ID                    *OrderBy           `json:"id,omitempty"`
	IsDefault             *OrderBy           `json:"isDefault,omitempty"`
	StripePaymentMethodID *OrderBy           `json:"stripePaymentMethodId,omitempty"`
	User                  *UsersOrderBy      `json:"user,omitempty"`
	Workspace             *WorkspacesOrderBy `json:"workspace,omitempty"`
	WorkspaceID           *OrderBy           `json:"workspaceId,omitempty"`
}

Ordering options when selecting data from "payment_methods".

type PaymentMethodsPkColumnsInput 

type PaymentMethodsPkColumnsInput struct {
	ID string `json:"id"`
}

primary key columns input for table: payment_methods

type PaymentMethodsSelectColumn 

type PaymentMethodsSelectColumn string

select columns of table "payment_methods" 

const (
	// column name
	PaymentMethodsSelectColumnAddedByUserID PaymentMethodsSelectColumn = "addedByUserId"
	// column name
	PaymentMethodsSelectColumnCardBrand PaymentMethodsSelectColumn = "cardBrand"
	// column name
	PaymentMethodsSelectColumnCardExpMonth PaymentMethodsSelectColumn = "cardExpMonth"
	// column name
	PaymentMethodsSelectColumnCardExpYear PaymentMethodsSelectColumn = "cardExpYear"
	// column name
	PaymentMethodsSelectColumnCardLast4 PaymentMethodsSelectColumn = "cardLast4"
	// column name
	PaymentMethodsSelectColumnCreatedAt PaymentMethodsSelectColumn = "createdAt"
	// column name
	PaymentMethodsSelectColumnID PaymentMethodsSelectColumn = "id"
	// column name
	PaymentMethodsSelectColumnIsDefault PaymentMethodsSelectColumn = "isDefault"
	// column name
	PaymentMethodsSelectColumnStripePaymentMethodID PaymentMethodsSelectColumn = "stripePaymentMethodId"
	// column name
	PaymentMethodsSelectColumnWorkspaceID PaymentMethodsSelectColumn = "workspaceId"
)

func (PaymentMethodsSelectColumn) IsValid 

func (e PaymentMethodsSelectColumn) IsValid() bool

func (PaymentMethodsSelectColumn) MarshalGQL 

func (e PaymentMethodsSelectColumn) MarshalGQL(w io.Writer)

func (PaymentMethodsSelectColumn) String 

func (e PaymentMethodsSelectColumn) String() string

func (*PaymentMethodsSelectColumn) UnmarshalGQL 

func (e *PaymentMethodsSelectColumn) UnmarshalGQL(v interface{}) error

type PaymentMethodsSetInput 

type PaymentMethodsSetInput struct {
	IsDefault *bool `json:"isDefault,omitempty"`
}

input type for updating data in table "payment_methods"

type PaymentMethodsStddevOrderBy 

type PaymentMethodsStddevOrderBy struct {
	CardExpMonth *OrderBy `json:"cardExpMonth,omitempty"`
	CardExpYear  *OrderBy `json:"cardExpYear,omitempty"`
}

order by stddev() on columns of table "payment_methods"

type PaymentMethodsStddevPopOrderBy 

type PaymentMethodsStddevPopOrderBy struct {
	CardExpMonth *OrderBy `json:"cardExpMonth,omitempty"`
	CardExpYear  *OrderBy `json:"cardExpYear,omitempty"`
}

order by stddev_pop() on columns of table "payment_methods"

type PaymentMethodsStddevSampOrderBy 

type PaymentMethodsStddevSampOrderBy struct {
	CardExpMonth *OrderBy `json:"cardExpMonth,omitempty"`
	CardExpYear  *OrderBy `json:"cardExpYear,omitempty"`
}

order by stddev_samp() on columns of table "payment_methods"

type PaymentMethodsStreamCursorInput 

type PaymentMethodsStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *PaymentMethodsStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "paymentMethods"

type PaymentMethodsStreamCursorValueInput 

type PaymentMethodsStreamCursorValueInput struct {
	AddedByUserID         *string    `json:"addedByUserId,omitempty"`
	CardBrand             *string    `json:"cardBrand,omitempty"`
	CardExpMonth          *int64     `json:"cardExpMonth,omitempty"`
	CardExpYear           *int64     `json:"cardExpYear,omitempty"`
	CardLast4             *string    `json:"cardLast4,omitempty"`
	CreatedAt             *time.Time `json:"createdAt,omitempty"`
	ID                    *string    `json:"id,omitempty"`
	IsDefault             *bool      `json:"isDefault,omitempty"`
	StripePaymentMethodID *string    `json:"stripePaymentMethodId,omitempty"`
	WorkspaceID           *string    `json:"workspaceId,omitempty"`
}

Initial value of the column from where the streaming should start

type PaymentMethodsSumOrderBy 

type PaymentMethodsSumOrderBy struct {
	CardExpMonth *OrderBy `json:"cardExpMonth,omitempty"`
	CardExpYear  *OrderBy `json:"cardExpYear,omitempty"`
}

order by sum() on columns of table "payment_methods"

type PaymentMethodsUpdateColumn 

type PaymentMethodsUpdateColumn string

update columns of table "payment_methods" 

const (
	// column name
	PaymentMethodsUpdateColumnIsDefault PaymentMethodsUpdateColumn = "isDefault"
)

func (PaymentMethodsUpdateColumn) IsValid 

func (e PaymentMethodsUpdateColumn) IsValid() bool

func (PaymentMethodsUpdateColumn) MarshalGQL 

func (e PaymentMethodsUpdateColumn) MarshalGQL(w io.Writer)

func (PaymentMethodsUpdateColumn) String 

func (e PaymentMethodsUpdateColumn) String() string

func (*PaymentMethodsUpdateColumn) UnmarshalGQL 

func (e *PaymentMethodsUpdateColumn) UnmarshalGQL(v interface{}) error

type PaymentMethodsUpdates 

type PaymentMethodsUpdates struct {
	// sets the columns of the filtered rows to the given values
	Set *PaymentMethodsSetInput `json:"_set,omitempty"`
	// filter the rows which have to be updated
	Where *PaymentMethodsBoolExp `json:"where"`
}

type PaymentMethodsVarPopOrderBy 

type PaymentMethodsVarPopOrderBy struct {
	CardExpMonth *OrderBy `json:"cardExpMonth,omitempty"`
	CardExpYear  *OrderBy `json:"cardExpYear,omitempty"`
}

order by var_pop() on columns of table "payment_methods"

type PaymentMethodsVarSampOrderBy 

type PaymentMethodsVarSampOrderBy struct {
	CardExpMonth *OrderBy `json:"cardExpMonth,omitempty"`
	CardExpYear  *OrderBy `json:"cardExpYear,omitempty"`
}

order by var_samp() on columns of table "payment_methods"

type PaymentMethodsVarianceOrderBy 

type PaymentMethodsVarianceOrderBy struct {
	CardExpMonth *OrderBy `json:"cardExpMonth,omitempty"`
	CardExpYear  *OrderBy `json:"cardExpYear,omitempty"`
}

order by variance() on columns of table "payment_methods"

type Plans 

type Plans struct {
	// An array relationship
	Apps                               []*Apps   `json:"apps"`
	CreatedAt                          time.Time `json:"createdAt"`
	Deprecated                         bool      `json:"deprecated"`
	FeatureBackupEnabled               bool      `json:"featureBackupEnabled"`
	FeatureCustomDomainsEnabled        bool      `json:"featureCustomDomainsEnabled"`
	FeatureCustomEmailTemplatesEnabled bool      `json:"featureCustomEmailTemplatesEnabled"`
	FeatureMaxDbSize                   int64     `json:"featureMaxDbSize"`
	ID                                 string    `json:"id"`
	Individual                         bool      `json:"individual"`
	IsDefault                          bool      `json:"isDefault"`
	IsFree                             bool      `json:"isFree"`
	Name                               string    `json:"name"`
	Price                              int64     `json:"price"`
	Sort                               int64     `json:"sort"`
	UpatedAt                           time.Time `json:"upatedAt"`
}

columns and relationships of "plans"

type PlansBoolExp 

type PlansBoolExp struct {
	And                                []*PlansBoolExp           `json:"_and,omitempty"`
	Not                                *PlansBoolExp             `json:"_not,omitempty"`
	Or                                 []*PlansBoolExp           `json:"_or,omitempty"`
	Apps                               *AppsBoolExp              `json:"apps,omitempty"`
	CreatedAt                          *TimestamptzComparisonExp `json:"createdAt,omitempty"`
	Deprecated                         *BooleanComparisonExp     `json:"deprecated,omitempty"`
	FeatureBackupEnabled               *BooleanComparisonExp     `json:"featureBackupEnabled,omitempty"`
	FeatureCustomDomainsEnabled        *BooleanComparisonExp     `json:"featureCustomDomainsEnabled,omitempty"`
	FeatureCustomEmailTemplatesEnabled *BooleanComparisonExp     `json:"featureCustomEmailTemplatesEnabled,omitempty"`
	FeatureMaxDbSize                   *IntComparisonExp         `json:"featureMaxDbSize,omitempty"`
	ID                                 *UUIDComparisonExp        `json:"id,omitempty"`
	Individual                         *BooleanComparisonExp     `json:"individual,omitempty"`
	IsDefault                          *BooleanComparisonExp     `json:"isDefault,omitempty"`
	IsFree                             *BooleanComparisonExp     `json:"isFree,omitempty"`
	Name                               *StringComparisonExp      `json:"name,omitempty"`
	Price                              *IntComparisonExp         `json:"price,omitempty"`
	Sort                               *IntComparisonExp         `json:"sort,omitempty"`
	UpatedAt                           *TimestamptzComparisonExp `json:"upatedAt,omitempty"`
}

Boolean expression to filter rows from the table "plans". All fields are combined with a logical 'AND'.

type PlansOrderBy 

type PlansOrderBy struct {
	AppsAggregate                      *AppsAggregateOrderBy `json:"apps_aggregate,omitempty"`
	CreatedAt                          *OrderBy              `json:"createdAt,omitempty"`
	Deprecated                         *OrderBy              `json:"deprecated,omitempty"`
	FeatureBackupEnabled               *OrderBy              `json:"featureBackupEnabled,omitempty"`
	FeatureCustomDomainsEnabled        *OrderBy              `json:"featureCustomDomainsEnabled,omitempty"`
	FeatureCustomEmailTemplatesEnabled *OrderBy              `json:"featureCustomEmailTemplatesEnabled,omitempty"`
	FeatureMaxDbSize                   *OrderBy              `json:"featureMaxDbSize,omitempty"`
	ID                                 *OrderBy              `json:"id,omitempty"`
	Individual                         *OrderBy              `json:"individual,omitempty"`
	IsDefault                          *OrderBy              `json:"isDefault,omitempty"`
	IsFree                             *OrderBy              `json:"isFree,omitempty"`
	Name                               *OrderBy              `json:"name,omitempty"`
	Price                              *OrderBy              `json:"price,omitempty"`
	Sort                               *OrderBy              `json:"sort,omitempty"`
	UpatedAt                           *OrderBy              `json:"upatedAt,omitempty"`
}

Ordering options when selecting data from "plans".

type PlansSelectColumn 

type PlansSelectColumn string

select columns of table "plans" 

const (
	// column name
	PlansSelectColumnCreatedAt PlansSelectColumn = "createdAt"
	// column name
	PlansSelectColumnDeprecated PlansSelectColumn = "deprecated"
	// column name
	PlansSelectColumnFeatureBackupEnabled PlansSelectColumn = "featureBackupEnabled"
	// column name
	PlansSelectColumnFeatureCustomDomainsEnabled PlansSelectColumn = "featureCustomDomainsEnabled"
	// column name
	PlansSelectColumnFeatureCustomEmailTemplatesEnabled PlansSelectColumn = "featureCustomEmailTemplatesEnabled"
	// column name
	PlansSelectColumnFeatureMaxDbSize PlansSelectColumn = "featureMaxDbSize"
	// column name
	PlansSelectColumnID PlansSelectColumn = "id"
	// column name
	PlansSelectColumnIndividual PlansSelectColumn = "individual"
	// column name
	PlansSelectColumnIsDefault PlansSelectColumn = "isDefault"
	// column name
	PlansSelectColumnIsFree PlansSelectColumn = "isFree"
	// column name
	PlansSelectColumnName PlansSelectColumn = "name"
	// column name
	PlansSelectColumnPrice PlansSelectColumn = "price"
	// column name
	PlansSelectColumnSort PlansSelectColumn = "sort"
	// column name
	PlansSelectColumnUpatedAt PlansSelectColumn = "upatedAt"
)

func (PlansSelectColumn) IsValid 

func (e PlansSelectColumn) IsValid() bool

func (PlansSelectColumn) MarshalGQL 

func (e PlansSelectColumn) MarshalGQL(w io.Writer)

func (PlansSelectColumn) String 

func (e PlansSelectColumn) String() string

func (*PlansSelectColumn) UnmarshalGQL 

func (e *PlansSelectColumn) UnmarshalGQL(v interface{}) error

type PlansStreamCursorInput 

type PlansStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *PlansStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "plans"

type PlansStreamCursorValueInput 

type PlansStreamCursorValueInput struct {
	CreatedAt                          *time.Time `json:"createdAt,omitempty"`
	Deprecated                         *bool      `json:"deprecated,omitempty"`
	FeatureBackupEnabled               *bool      `json:"featureBackupEnabled,omitempty"`
	FeatureCustomDomainsEnabled        *bool      `json:"featureCustomDomainsEnabled,omitempty"`
	FeatureCustomEmailTemplatesEnabled *bool      `json:"featureCustomEmailTemplatesEnabled,omitempty"`
	FeatureMaxDbSize                   *int64     `json:"featureMaxDbSize,omitempty"`
	ID                                 *string    `json:"id,omitempty"`
	Individual                         *bool      `json:"individual,omitempty"`
	IsDefault                          *bool      `json:"isDefault,omitempty"`
	IsFree                             *bool      `json:"isFree,omitempty"`
	Name                               *string    `json:"name,omitempty"`
	Price                              *int64     `json:"price,omitempty"`
	Sort                               *int64     `json:"sort,omitempty"`
	UpatedAt                           *time.Time `json:"upatedAt,omitempty"`
}

Initial value of the column from where the streaming should start

type ProjectStatusResponse added in v1.18.1 

type ProjectStatusResponse struct {
	Services []*ServiceStatus `json:"services"`
}

type QueryRoot 

type QueryRoot struct {
}

type RegionTypeEnum added in v1.5.0 

type RegionTypeEnum string
const (
	// Private region available to selected workspaces
	RegionTypeEnumPrivate RegionTypeEnum = "private"
	// Public region available to all Nhost projects
	RegionTypeEnumPublic RegionTypeEnum = "public"
)

func (RegionTypeEnum) IsValid added in v1.5.0 

func (e RegionTypeEnum) IsValid() bool

func (RegionTypeEnum) MarshalGQL added in v1.5.0 

func (e RegionTypeEnum) MarshalGQL(w io.Writer)

func (RegionTypeEnum) String added in v1.5.0 

func (e RegionTypeEnum) String() string

func (*RegionTypeEnum) UnmarshalGQL added in v1.5.0 

func (e *RegionTypeEnum) UnmarshalGQL(v interface{}) error

type RegionTypeEnumComparisonExp added in v1.5.0 

type RegionTypeEnumComparisonExp struct {
	Eq     *RegionTypeEnum  `json:"_eq,omitempty"`
	In     []RegionTypeEnum `json:"_in,omitempty"`
	IsNull *bool            `json:"_is_null,omitempty"`
	Neq    *RegionTypeEnum  `json:"_neq,omitempty"`
	Nin    []RegionTypeEnum `json:"_nin,omitempty"`
}

Boolean expression to compare columns of type "region_type_enum". All fields are combined with logical 'AND'.

type Regions 

type Regions struct {
	Active bool `json:"active"`
	// An object relationship
	AllowedWorkspaces *RegionsAllowedWorkspace `json:"allowedWorkspaces,omitempty"`
	// An array relationship
	Apps    []*Apps `json:"apps"`
	AwsName string  `json:"awsName"`
	City    string  `json:"city"`
	// An object relationship
	Country         *Countries `json:"country"`
	CountryCode     string     `json:"countryCode"`
	Description     *string    `json:"description,omitempty"`
	Domain          string     `json:"domain"`
	ID              string     `json:"id"`
	IsGdprCompliant bool       `json:"isGdprCompliant"`
	Name            string     `json:"name"`
	// An array relationship
	RegionsAllowedWorkspaces []*RegionsAllowedWorkspace `json:"regions_allowed_workspaces"`
	Type                     RegionTypeEnum             `json:"type"`
}

columns and relationships of "regions"

type RegionsAggregateOrderBy 

type RegionsAggregateOrderBy struct {
	Count *OrderBy           `json:"count,omitempty"`
	Max   *RegionsMaxOrderBy `json:"max,omitempty"`
	Min   *RegionsMinOrderBy `json:"min,omitempty"`
}

order by aggregate values of table "regions"

type RegionsAllowedWorkspace added in v1.5.0 

type RegionsAllowedWorkspace struct {
	CreatedAt   time.Time `json:"created_at"`
	Description string    `json:"description"`
	ID          string    `json:"id"`
	// An object relationship
	Region    *Regions  `json:"region,omitempty"`
	RegionID  string    `json:"region_id"`
	UpdatedAt time.Time `json:"updated_at"`
	// An object relationship
	Workspace   *Workspaces `json:"workspace,omitempty"`
	WorkspaceID string      `json:"workspace_id"`
}

columns and relationships of "regions_allowed_workspace"

type RegionsAllowedWorkspaceAggregateOrderBy added in v1.5.0 

type RegionsAllowedWorkspaceAggregateOrderBy struct {
	Count *OrderBy                           `json:"count,omitempty"`
	Max   *RegionsAllowedWorkspaceMaxOrderBy `json:"max,omitempty"`
	Min   *RegionsAllowedWorkspaceMinOrderBy `json:"min,omitempty"`
}

order by aggregate values of table "regions_allowed_workspace"

type RegionsAllowedWorkspaceBoolExp added in v1.5.0 

type RegionsAllowedWorkspaceBoolExp struct {
	And         []*RegionsAllowedWorkspaceBoolExp `json:"_and,omitempty"`
	Not         *RegionsAllowedWorkspaceBoolExp   `json:"_not,omitempty"`
	Or          []*RegionsAllowedWorkspaceBoolExp `json:"_or,omitempty"`
	CreatedAt   *TimestamptzComparisonExp         `json:"created_at,omitempty"`
	Description *StringComparisonExp              `json:"description,omitempty"`
	ID          *UUIDComparisonExp                `json:"id,omitempty"`
	Region      *RegionsBoolExp                   `json:"region,omitempty"`
	RegionID    *UUIDComparisonExp                `json:"region_id,omitempty"`
	UpdatedAt   *TimestamptzComparisonExp         `json:"updated_at,omitempty"`
	Workspace   *WorkspacesBoolExp                `json:"workspace,omitempty"`
	WorkspaceID *UUIDComparisonExp                `json:"workspace_id,omitempty"`
}

Boolean expression to filter rows from the table "regions_allowed_workspace". All fields are combined with a logical 'AND'.

type RegionsAllowedWorkspaceMaxOrderBy added in v1.5.0 

type RegionsAllowedWorkspaceMaxOrderBy struct {
	CreatedAt   *OrderBy `json:"created_at,omitempty"`
	Description *OrderBy `json:"description,omitempty"`
	ID          *OrderBy `json:"id,omitempty"`
	RegionID    *OrderBy `json:"region_id,omitempty"`
	UpdatedAt   *OrderBy `json:"updated_at,omitempty"`
	WorkspaceID *OrderBy `json:"workspace_id,omitempty"`
}

order by max() on columns of table "regions_allowed_workspace"

type RegionsAllowedWorkspaceMinOrderBy added in v1.5.0 

type RegionsAllowedWorkspaceMinOrderBy struct {
	CreatedAt   *OrderBy `json:"created_at,omitempty"`
	Description *OrderBy `json:"description,omitempty"`
	ID          *OrderBy `json:"id,omitempty"`
	RegionID    *OrderBy `json:"region_id,omitempty"`
	UpdatedAt   *OrderBy `json:"updated_at,omitempty"`
	WorkspaceID *OrderBy `json:"workspace_id,omitempty"`
}

order by min() on columns of table "regions_allowed_workspace"

type RegionsAllowedWorkspaceOrderBy added in v1.5.0 

type RegionsAllowedWorkspaceOrderBy struct {
	CreatedAt   *OrderBy           `json:"created_at,omitempty"`
	Description *OrderBy           `json:"description,omitempty"`
	ID          *OrderBy           `json:"id,omitempty"`
	Region      *RegionsOrderBy    `json:"region,omitempty"`
	RegionID    *OrderBy           `json:"region_id,omitempty"`
	UpdatedAt   *OrderBy           `json:"updated_at,omitempty"`
	Workspace   *WorkspacesOrderBy `json:"workspace,omitempty"`
	WorkspaceID *OrderBy           `json:"workspace_id,omitempty"`
}

Ordering options when selecting data from "regions_allowed_workspace".

type RegionsAllowedWorkspaceSelectColumn added in v1.5.0 

type RegionsAllowedWorkspaceSelectColumn string

select columns of table "regions_allowed_workspace" 

const (
	// column name
	RegionsAllowedWorkspaceSelectColumnCreatedAt RegionsAllowedWorkspaceSelectColumn = "created_at"
	// column name
	RegionsAllowedWorkspaceSelectColumnDescription RegionsAllowedWorkspaceSelectColumn = "description"
	// column name
	RegionsAllowedWorkspaceSelectColumnID RegionsAllowedWorkspaceSelectColumn = "id"
	// column name
	RegionsAllowedWorkspaceSelectColumnRegionID RegionsAllowedWorkspaceSelectColumn = "region_id"
	// column name
	RegionsAllowedWorkspaceSelectColumnUpdatedAt RegionsAllowedWorkspaceSelectColumn = "updated_at"
	// column name
	RegionsAllowedWorkspaceSelectColumnWorkspaceID RegionsAllowedWorkspaceSelectColumn = "workspace_id"
)

func (RegionsAllowedWorkspaceSelectColumn) IsValid added in v1.5.0 

func (e RegionsAllowedWorkspaceSelectColumn) IsValid() bool

func (RegionsAllowedWorkspaceSelectColumn) MarshalGQL added in v1.5.0 

func (e RegionsAllowedWorkspaceSelectColumn) MarshalGQL(w io.Writer)

func (RegionsAllowedWorkspaceSelectColumn) String added in v1.5.0 

func (e RegionsAllowedWorkspaceSelectColumn) String() string

func (*RegionsAllowedWorkspaceSelectColumn) UnmarshalGQL added in v1.5.0 

func (e *RegionsAllowedWorkspaceSelectColumn) UnmarshalGQL(v interface{}) error

type RegionsAllowedWorkspaceStreamCursorInput added in v1.5.0 

type RegionsAllowedWorkspaceStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *RegionsAllowedWorkspaceStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "regions_allowed_workspace"

type RegionsAllowedWorkspaceStreamCursorValueInput added in v1.5.0 

type RegionsAllowedWorkspaceStreamCursorValueInput struct {
	CreatedAt   *time.Time `json:"created_at,omitempty"`
	Description *string    `json:"description,omitempty"`
	ID          *string    `json:"id,omitempty"`
	RegionID    *string    `json:"region_id,omitempty"`
	UpdatedAt   *time.Time `json:"updated_at,omitempty"`
	WorkspaceID *string    `json:"workspace_id,omitempty"`
}

Initial value of the column from where the streaming should start

type RegionsBoolExp 

type RegionsBoolExp struct {
	And                      []*RegionsBoolExp               `json:"_and,omitempty"`
	Not                      *RegionsBoolExp                 `json:"_not,omitempty"`
	Or                       []*RegionsBoolExp               `json:"_or,omitempty"`
	Active                   *BooleanComparisonExp           `json:"active,omitempty"`
	AllowedWorkspaces        *RegionsAllowedWorkspaceBoolExp `json:"allowedWorkspaces,omitempty"`
	Apps                     *AppsBoolExp                    `json:"apps,omitempty"`
	AwsName                  *StringComparisonExp            `json:"awsName,omitempty"`
	City                     *StringComparisonExp            `json:"city,omitempty"`
	Country                  *CountriesBoolExp               `json:"country,omitempty"`
	CountryCode              *StringComparisonExp            `json:"countryCode,omitempty"`
	Description              *StringComparisonExp            `json:"description,omitempty"`
	Domain                   *StringComparisonExp            `json:"domain,omitempty"`
	ID                       *UUIDComparisonExp              `json:"id,omitempty"`
	IsGdprCompliant          *BooleanComparisonExp           `json:"isGdprCompliant,omitempty"`
	Name                     *StringComparisonExp            `json:"name,omitempty"`
	RegionsAllowedWorkspaces *RegionsAllowedWorkspaceBoolExp `json:"regions_allowed_workspaces,omitempty"`
	Type                     *RegionTypeEnumComparisonExp    `json:"type,omitempty"`
}

Boolean expression to filter rows from the table "regions". All fields are combined with a logical 'AND'.

type RegionsMaxOrderBy 

type RegionsMaxOrderBy struct {
	AwsName     *OrderBy `json:"awsName,omitempty"`
	City        *OrderBy `json:"city,omitempty"`
	CountryCode *OrderBy `json:"countryCode,omitempty"`
	Description *OrderBy `json:"description,omitempty"`
	Domain      *OrderBy `json:"domain,omitempty"`
	ID          *OrderBy `json:"id,omitempty"`
	Name        *OrderBy `json:"name,omitempty"`
}

order by max() on columns of table "regions"

type RegionsMinOrderBy 

type RegionsMinOrderBy struct {
	AwsName     *OrderBy `json:"awsName,omitempty"`
	City        *OrderBy `json:"city,omitempty"`
	CountryCode *OrderBy `json:"countryCode,omitempty"`
	Description *OrderBy `json:"description,omitempty"`
	Domain      *OrderBy `json:"domain,omitempty"`
	ID          *OrderBy `json:"id,omitempty"`
	Name        *OrderBy `json:"name,omitempty"`
}

order by min() on columns of table "regions"

type RegionsOrderBy 

type RegionsOrderBy struct {
	Active                            *OrderBy                                 `json:"active,omitempty"`
	AllowedWorkspaces                 *RegionsAllowedWorkspaceOrderBy          `json:"allowedWorkspaces,omitempty"`
	AppsAggregate                     *AppsAggregateOrderBy                    `json:"apps_aggregate,omitempty"`
	AwsName                           *OrderBy                                 `json:"awsName,omitempty"`
	City                              *OrderBy                                 `json:"city,omitempty"`
	Country                           *CountriesOrderBy                        `json:"country,omitempty"`
	CountryCode                       *OrderBy                                 `json:"countryCode,omitempty"`
	Description                       *OrderBy                                 `json:"description,omitempty"`
	Domain                            *OrderBy                                 `json:"domain,omitempty"`
	ID                                *OrderBy                                 `json:"id,omitempty"`
	IsGdprCompliant                   *OrderBy                                 `json:"isGdprCompliant,omitempty"`
	Name                              *OrderBy                                 `json:"name,omitempty"`
	RegionsAllowedWorkspacesAggregate *RegionsAllowedWorkspaceAggregateOrderBy `json:"regions_allowed_workspaces_aggregate,omitempty"`
	Type                              *OrderBy                                 `json:"type,omitempty"`
}

Ordering options when selecting data from "regions".

type RegionsSelectColumn 

type RegionsSelectColumn string

select columns of table "regions" 

const (
	// column name
	RegionsSelectColumnActive RegionsSelectColumn = "active"
	// column name
	RegionsSelectColumnAwsName RegionsSelectColumn = "awsName"
	// column name
	RegionsSelectColumnCity RegionsSelectColumn = "city"
	// column name
	RegionsSelectColumnCountryCode RegionsSelectColumn = "countryCode"
	// column name
	RegionsSelectColumnDescription RegionsSelectColumn = "description"
	// column name
	RegionsSelectColumnDomain RegionsSelectColumn = "domain"
	// column name
	RegionsSelectColumnID RegionsSelectColumn = "id"
	// column name
	RegionsSelectColumnIsGdprCompliant RegionsSelectColumn = "isGdprCompliant"
	// column name
	RegionsSelectColumnName RegionsSelectColumn = "name"
	// column name
	RegionsSelectColumnType RegionsSelectColumn = "type"
)

func (RegionsSelectColumn) IsValid 

func (e RegionsSelectColumn) IsValid() bool

func (RegionsSelectColumn) MarshalGQL 

func (e RegionsSelectColumn) MarshalGQL(w io.Writer)

func (RegionsSelectColumn) String 

func (e RegionsSelectColumn) String() string

func (*RegionsSelectColumn) UnmarshalGQL 

func (e *RegionsSelectColumn) UnmarshalGQL(v interface{}) error

type RegionsStreamCursorInput 

type RegionsStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *RegionsStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "regions"

type RegionsStreamCursorValueInput 

type RegionsStreamCursorValueInput struct {
	Active          *bool           `json:"active,omitempty"`
	AwsName         *string         `json:"awsName,omitempty"`
	City            *string         `json:"city,omitempty"`
	CountryCode     *string         `json:"countryCode,omitempty"`
	Description     *string         `json:"description,omitempty"`
	Domain          *string         `json:"domain,omitempty"`
	ID              *string         `json:"id,omitempty"`
	IsGdprCompliant *bool           `json:"isGdprCompliant,omitempty"`
	Name            *string         `json:"name,omitempty"`
	Type            *RegionTypeEnum `json:"type,omitempty"`
}

Initial value of the column from where the streaming should start

type ReplaceRunServiceConfig added in v1.5.0 

type ReplaceRunServiceConfig struct {
	ReplaceRunServiceConfig ReplaceRunServiceConfig_ReplaceRunServiceConfig "json:\"replaceRunServiceConfig\" graphql:\"replaceRunServiceConfig\""
}

func (*ReplaceRunServiceConfig) GetReplaceRunServiceConfig added in v1.5.0 

func (t *ReplaceRunServiceConfig) GetReplaceRunServiceConfig() *ReplaceRunServiceConfig_ReplaceRunServiceConfig

type ReplaceRunServiceConfig_ReplaceRunServiceConfig added in v1.5.0 

type ReplaceRunServiceConfig_ReplaceRunServiceConfig struct {
	Typename *string "json:\"__typename,omitempty\" graphql:\"__typename\""
}

func (*ReplaceRunServiceConfig_ReplaceRunServiceConfig) GetTypename added in v1.5.0 

func (t *ReplaceRunServiceConfig_ReplaceRunServiceConfig) GetTypename() *string

type ReplicaStatus added in v1.18.1 

type ReplicaStatus struct {
	Date   string            `json:"date"`
	Errors []*ContainerError `json:"errors"`
	Ready  bool              `json:"ready"`
}

type RunService added in v1.5.0 

type RunService struct {
	// An object relationship
	App       *Apps                   `json:"app"`
	AppID     string                  `json:"appID"`
	Config    *ConfigRunServiceConfig `json:"config,omitempty"`
	CreatedAt time.Time               `json:"createdAt"`
	// An object relationship
	Creator       *Users    `json:"creator"`
	CreatorUserID string    `json:"creatorUserId"`
	ID            string    `json:"id"`
	Subdomain     string    `json:"subdomain"`
	UpdatedAt     time.Time `json:"updatedAt"`
}

columns and relationships of "run_service"

type RunServiceAggregate added in v1.5.0 

type RunServiceAggregate struct {
	Aggregate *RunServiceAggregateFields `json:"aggregate,omitempty"`
	Nodes     []*RunService              `json:"nodes"`
}

aggregated selection of "run_service"

type RunServiceAggregateBoolExp added in v1.5.0 

type RunServiceAggregateBoolExp struct {
	Count *RunServiceAggregateBoolExpCount `json:"count,omitempty"`
}

type RunServiceAggregateBoolExpCount added in v1.5.0 

type RunServiceAggregateBoolExpCount struct {
	Arguments []RunServiceSelectColumn `json:"arguments,omitempty"`
	Distinct  *bool                    `json:"distinct,omitempty"`
	Filter    *RunServiceBoolExp       `json:"filter,omitempty"`
	Predicate *IntComparisonExp        `json:"predicate"`
}

type RunServiceAggregateFields added in v1.5.0 

type RunServiceAggregateFields struct {
	Count int64                `json:"count"`
	Max   *RunServiceMaxFields `json:"max,omitempty"`
	Min   *RunServiceMinFields `json:"min,omitempty"`
}

aggregate fields of "run_service"

type RunServiceAggregateOrderBy added in v1.5.0 

type RunServiceAggregateOrderBy struct {
	Count *OrderBy              `json:"count,omitempty"`
	Max   *RunServiceMaxOrderBy `json:"max,omitempty"`
	Min   *RunServiceMinOrderBy `json:"min,omitempty"`
}

order by aggregate values of table "run_service"

type RunServiceArrRelInsertInput added in v1.5.0 

type RunServiceArrRelInsertInput struct {
	Data []*RunServiceInsertInput `json:"data"`
	// upsert condition
	OnConflict *RunServiceOnConflict `json:"on_conflict,omitempty"`
}

input type for inserting array relation for remote table "run_service"

type RunServiceBoolExp added in v1.5.0 

type RunServiceBoolExp struct {
	And           []*RunServiceBoolExp      `json:"_and,omitempty"`
	Not           *RunServiceBoolExp        `json:"_not,omitempty"`
	Or            []*RunServiceBoolExp      `json:"_or,omitempty"`
	App           *AppsBoolExp              `json:"app,omitempty"`
	AppID         *UUIDComparisonExp        `json:"appID,omitempty"`
	CreatedAt     *TimestamptzComparisonExp `json:"createdAt,omitempty"`
	Creator       *UsersBoolExp             `json:"creator,omitempty"`
	CreatorUserID *UUIDComparisonExp        `json:"creatorUserId,omitempty"`
	ID            *UUIDComparisonExp        `json:"id,omitempty"`
	Subdomain     *StringComparisonExp      `json:"subdomain,omitempty"`
	UpdatedAt     *TimestamptzComparisonExp `json:"updatedAt,omitempty"`
}

Boolean expression to filter rows from the table "run_service". All fields are combined with a logical 'AND'.

type RunServiceConstraint added in v1.5.0 

type RunServiceConstraint string

unique or primary key constraints on table "run_service" 

const (
	// unique or primary key constraint on columns "id"
	RunServiceConstraintRunServicePkey RunServiceConstraint = "run_service_pkey"
	// unique or primary key constraint on columns "subdomain"
	RunServiceConstraintRunServiceSubdomainKey RunServiceConstraint = "run_service_subdomain_key"
)

func (RunServiceConstraint) IsValid added in v1.5.0 

func (e RunServiceConstraint) IsValid() bool

func (RunServiceConstraint) MarshalGQL added in v1.5.0 

func (e RunServiceConstraint) MarshalGQL(w io.Writer)

func (RunServiceConstraint) String added in v1.5.0 

func (e RunServiceConstraint) String() string

func (*RunServiceConstraint) UnmarshalGQL added in v1.5.0 

func (e *RunServiceConstraint) UnmarshalGQL(v interface{}) error

type RunServiceInsertInput added in v1.5.0 

type RunServiceInsertInput struct {
	App   *AppsObjRelInsertInput `json:"app,omitempty"`
	AppID *string                `json:"appID,omitempty"`
}

input type for inserting data into table "run_service"

type RunServiceMaxFields added in v1.5.0 

type RunServiceMaxFields struct {
	AppID         *string    `json:"appID,omitempty"`
	CreatedAt     *time.Time `json:"createdAt,omitempty"`
	CreatorUserID *string    `json:"creatorUserId,omitempty"`
	ID            *string    `json:"id,omitempty"`
	Subdomain     *string    `json:"subdomain,omitempty"`
	UpdatedAt     *time.Time `json:"updatedAt,omitempty"`
}

aggregate max on columns

type RunServiceMaxOrderBy added in v1.5.0 

type RunServiceMaxOrderBy struct {
	AppID         *OrderBy `json:"appID,omitempty"`
	CreatedAt     *OrderBy `json:"createdAt,omitempty"`
	CreatorUserID *OrderBy `json:"creatorUserId,omitempty"`
	ID            *OrderBy `json:"id,omitempty"`
	Subdomain     *OrderBy `json:"subdomain,omitempty"`
	UpdatedAt     *OrderBy `json:"updatedAt,omitempty"`
}

order by max() on columns of table "run_service"

type RunServiceMinFields added in v1.5.0 

type RunServiceMinFields struct {
	AppID         *string    `json:"appID,omitempty"`
	CreatedAt     *time.Time `json:"createdAt,omitempty"`
	CreatorUserID *string    `json:"creatorUserId,omitempty"`
	ID            *string    `json:"id,omitempty"`
	Subdomain     *string    `json:"subdomain,omitempty"`
	UpdatedAt     *time.Time `json:"updatedAt,omitempty"`
}

aggregate min on columns

type RunServiceMinOrderBy added in v1.5.0 

type RunServiceMinOrderBy struct {
	AppID         *OrderBy `json:"appID,omitempty"`
	CreatedAt     *OrderBy `json:"createdAt,omitempty"`
	CreatorUserID *OrderBy `json:"creatorUserId,omitempty"`
	ID            *OrderBy `json:"id,omitempty"`
	Subdomain     *OrderBy `json:"subdomain,omitempty"`
	UpdatedAt     *OrderBy `json:"updatedAt,omitempty"`
}

order by min() on columns of table "run_service"

type RunServiceMutationResponse added in v1.5.0 

type RunServiceMutationResponse struct {
	// number of rows affected by the mutation
	AffectedRows int64 `json:"affected_rows"`
	// data from the rows affected by the mutation
	Returning []*RunService `json:"returning"`
}

response of any mutation on the table "run_service"

type RunServiceOnConflict added in v1.5.0 

type RunServiceOnConflict struct {
	Constraint    RunServiceConstraint     `json:"constraint"`
	UpdateColumns []RunServiceUpdateColumn `json:"update_columns"`
	Where         *RunServiceBoolExp       `json:"where,omitempty"`
}

on_conflict condition type for table "run_service"

type RunServiceOrderBy added in v1.5.0 

type RunServiceOrderBy struct {
	App           *AppsOrderBy  `json:"app,omitempty"`
	AppID         *OrderBy      `json:"appID,omitempty"`
	CreatedAt     *OrderBy      `json:"createdAt,omitempty"`
	Creator       *UsersOrderBy `json:"creator,omitempty"`
	CreatorUserID *OrderBy      `json:"creatorUserId,omitempty"`
	ID            *OrderBy      `json:"id,omitempty"`
	Subdomain     *OrderBy      `json:"subdomain,omitempty"`
	UpdatedAt     *OrderBy      `json:"updatedAt,omitempty"`
}

Ordering options when selecting data from "run_service".

type RunServiceSelectColumn added in v1.5.0 

type RunServiceSelectColumn string

select columns of table "run_service" 

const (
	// column name
	RunServiceSelectColumnAppID RunServiceSelectColumn = "appID"
	// column name
	RunServiceSelectColumnCreatedAt RunServiceSelectColumn = "createdAt"
	// column name
	RunServiceSelectColumnCreatorUserID RunServiceSelectColumn = "creatorUserId"
	// column name
	RunServiceSelectColumnID RunServiceSelectColumn = "id"
	// column name
	RunServiceSelectColumnSubdomain RunServiceSelectColumn = "subdomain"
	// column name
	RunServiceSelectColumnUpdatedAt RunServiceSelectColumn = "updatedAt"
)

func (RunServiceSelectColumn) IsValid added in v1.5.0 

func (e RunServiceSelectColumn) IsValid() bool

func (RunServiceSelectColumn) MarshalGQL added in v1.5.0 

func (e RunServiceSelectColumn) MarshalGQL(w io.Writer)

func (RunServiceSelectColumn) String added in v1.5.0 

func (e RunServiceSelectColumn) String() string

func (*RunServiceSelectColumn) UnmarshalGQL added in v1.5.0 

func (e *RunServiceSelectColumn) UnmarshalGQL(v interface{}) error

type RunServiceStreamCursorInput added in v1.5.0 

type RunServiceStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *RunServiceStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "run_service"

type RunServiceStreamCursorValueInput added in v1.5.0 

type RunServiceStreamCursorValueInput struct {
	AppID         *string    `json:"appID,omitempty"`
	CreatedAt     *time.Time `json:"createdAt,omitempty"`
	CreatorUserID *string    `json:"creatorUserId,omitempty"`
	ID            *string    `json:"id,omitempty"`
	Subdomain     *string    `json:"subdomain,omitempty"`
	UpdatedAt     *time.Time `json:"updatedAt,omitempty"`
}

Initial value of the column from where the streaming should start

type RunServiceUpdateColumn added in v1.5.0 

type RunServiceUpdateColumn string

placeholder for update columns of table "run_service" (current role has no relevant permissions) 

const (
	// placeholder (do not use)
	RunServiceUpdateColumnPlaceholder RunServiceUpdateColumn = "_PLACEHOLDER"
)

func (RunServiceUpdateColumn) IsValid added in v1.5.0 

func (e RunServiceUpdateColumn) IsValid() bool

func (RunServiceUpdateColumn) MarshalGQL added in v1.5.0 

func (e RunServiceUpdateColumn) MarshalGQL(w io.Writer)

func (RunServiceUpdateColumn) String added in v1.5.0 

func (e RunServiceUpdateColumn) String() string

func (*RunServiceUpdateColumn) UnmarshalGQL added in v1.5.0 

func (e *RunServiceUpdateColumn) UnmarshalGQL(v interface{}) error

type ServiceState added in v1.18.1 

type ServiceState string
const (
	ServiceStateError       ServiceState = "Error"
	ServiceStateNone        ServiceState = "None"
	ServiceStateRunning     ServiceState = "Running"
	ServiceStateUpdateError ServiceState = "UpdateError"
	ServiceStateUpdating    ServiceState = "Updating"
)

func (ServiceState) IsValid added in v1.18.1 

func (e ServiceState) IsValid() bool

func (ServiceState) MarshalGQL added in v1.18.1 

func (e ServiceState) MarshalGQL(w io.Writer)

func (ServiceState) String added in v1.18.1 

func (e ServiceState) String() string

func (*ServiceState) UnmarshalGQL added in v1.18.1 

func (e *ServiceState) UnmarshalGQL(v interface{}) error

type ServiceStatus added in v1.18.1 

type ServiceStatus struct {
	Name     string           `json:"name"`
	Replicas []*ReplicaStatus `json:"replicas"`
	State    ServiceState     `json:"state"`
}

type SoftwareTypeEnum added in v1.9.3 

type SoftwareTypeEnum string
const (
	// Hasura Auth
	SoftwareTypeEnumAuth SoftwareTypeEnum = "Auth"
	// Graphite
	SoftwareTypeEnumGraphite SoftwareTypeEnum = "Graphite"
	// Hasura GraphQL Engine
	SoftwareTypeEnumHasura SoftwareTypeEnum = "Hasura"
	// PostgreSQL Database
	SoftwareTypeEnumPostgreSQL SoftwareTypeEnum = "PostgreSQL"
	// Hasura Storage
	SoftwareTypeEnumStorage SoftwareTypeEnum = "Storage"
)

func (SoftwareTypeEnum) IsValid added in v1.9.3 

func (e SoftwareTypeEnum) IsValid() bool

func (SoftwareTypeEnum) MarshalGQL added in v1.9.3 

func (e SoftwareTypeEnum) MarshalGQL(w io.Writer)

func (SoftwareTypeEnum) String added in v1.9.3 

func (e SoftwareTypeEnum) String() string

func (*SoftwareTypeEnum) UnmarshalGQL added in v1.9.3 

func (e *SoftwareTypeEnum) UnmarshalGQL(v interface{}) error

type SoftwareTypeEnumComparisonExp added in v1.9.3 

type SoftwareTypeEnumComparisonExp struct {
	Eq     *SoftwareTypeEnum  `json:"_eq,omitempty"`
	In     []SoftwareTypeEnum `json:"_in,omitempty"`
	IsNull *bool              `json:"_is_null,omitempty"`
	Neq    *SoftwareTypeEnum  `json:"_neq,omitempty"`
	Nin    []SoftwareTypeEnum `json:"_nin,omitempty"`
}

Boolean expression to compare columns of type "software_type_enum". All fields are combined with logical 'AND'.

type SoftwareVersions added in v1.9.3 

type SoftwareVersions struct {
	ID       string           `json:"id"`
	Software SoftwareTypeEnum `json:"software"`
	Version  string           `json:"version"`
}

columns and relationships of "software_versions"

type SoftwareVersionsBoolExp added in v1.9.3 

type SoftwareVersionsBoolExp struct {
	And      []*SoftwareVersionsBoolExp     `json:"_and,omitempty"`
	Not      *SoftwareVersionsBoolExp       `json:"_not,omitempty"`
	Or       []*SoftwareVersionsBoolExp     `json:"_or,omitempty"`
	ID       *UUIDComparisonExp             `json:"id,omitempty"`
	Software *SoftwareTypeEnumComparisonExp `json:"software,omitempty"`
	Version  *StringComparisonExp           `json:"version,omitempty"`
}

Boolean expression to filter rows from the table "software_versions". All fields are combined with a logical 'AND'.

type SoftwareVersionsOrderBy added in v1.9.3 

type SoftwareVersionsOrderBy struct {
	ID       *OrderBy `json:"id,omitempty"`
	Software *OrderBy `json:"software,omitempty"`
	Version  *OrderBy `json:"version,omitempty"`
}

Ordering options when selecting data from "software_versions".

type SoftwareVersionsSelectColumn added in v1.9.3 

type SoftwareVersionsSelectColumn string

select columns of table "software_versions" 

const (
	// column name
	SoftwareVersionsSelectColumnID SoftwareVersionsSelectColumn = "id"
	// column name
	SoftwareVersionsSelectColumnSoftware SoftwareVersionsSelectColumn = "software"
	// column name
	SoftwareVersionsSelectColumnVersion SoftwareVersionsSelectColumn = "version"
)

func (SoftwareVersionsSelectColumn) IsValid added in v1.9.3 

func (e SoftwareVersionsSelectColumn) IsValid() bool

func (SoftwareVersionsSelectColumn) MarshalGQL added in v1.9.3 

func (e SoftwareVersionsSelectColumn) MarshalGQL(w io.Writer)

func (SoftwareVersionsSelectColumn) String added in v1.9.3 

func (e SoftwareVersionsSelectColumn) String() string

func (*SoftwareVersionsSelectColumn) UnmarshalGQL added in v1.9.3 

func (e *SoftwareVersionsSelectColumn) UnmarshalGQL(v interface{}) error

type SoftwareVersionsStreamCursorInput added in v1.9.3 

type SoftwareVersionsStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *SoftwareVersionsStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "software_versions"

type SoftwareVersionsStreamCursorValueInput added in v1.9.3 

type SoftwareVersionsStreamCursorValueInput struct {
	ID       *string           `json:"id,omitempty"`
	Software *SoftwareTypeEnum `json:"software,omitempty"`
	Version  *string           `json:"version,omitempty"`
}

Initial value of the column from where the streaming should start

type StringComparisonExp 

type StringComparisonExp struct {
	Eq  *string `json:"_eq,omitempty"`
	Gt  *string `json:"_gt,omitempty"`
	Gte *string `json:"_gte,omitempty"`
	// does the column match the given case-insensitive pattern
	Ilike *string  `json:"_ilike,omitempty"`
	In    []string `json:"_in,omitempty"`
	// does the column match the given POSIX regular expression, case insensitive
	Iregex *string `json:"_iregex,omitempty"`
	IsNull *bool   `json:"_is_null,omitempty"`
	// does the column match the given pattern
	Like *string `json:"_like,omitempty"`
	Lt   *string `json:"_lt,omitempty"`
	Lte  *string `json:"_lte,omitempty"`
	Neq  *string `json:"_neq,omitempty"`
	// does the column NOT match the given case-insensitive pattern
	Nilike *string  `json:"_nilike,omitempty"`
	Nin    []string `json:"_nin,omitempty"`
	// does the column NOT match the given POSIX regular expression, case insensitive
	Niregex *string `json:"_niregex,omitempty"`
	// does the column NOT match the given pattern
	Nlike *string `json:"_nlike,omitempty"`
	// does the column NOT match the given POSIX regular expression, case sensitive
	Nregex *string `json:"_nregex,omitempty"`
	// does the column NOT match the given SQL regular expression
	Nsimilar *string `json:"_nsimilar,omitempty"`
	// does the column match the given POSIX regular expression, case sensitive
	Regex *string `json:"_regex,omitempty"`
	// does the column match the given SQL regular expression
	Similar *string `json:"_similar,omitempty"`
}

Boolean expression to compare columns of type "String". All fields are combined with logical 'AND'.

type SubscriptionRoot 

type SubscriptionRoot struct {
	// fetch data from the table: "announcements"
	Announcements []*Announcements `json:"announcements"`
	// fetch data from the table: "announcements" using primary key columns
	AnnouncementsByPk *Announcements `json:"announcements_by_pk,omitempty"`
	// fetch data from the table in a streaming manner: "announcements"
	AnnouncementsStream []*Announcements `json:"announcements_stream"`
	// fetch data from the table: "apps" using primary key columns
	App *Apps `json:"app,omitempty"`
	// fetch data from the table: "app_state_history"
	AppStateHistories []*AppStateHistory `json:"appStateHistories"`
	// fetch data from the table: "app_state_history" using primary key columns
	AppStateHistory *AppStateHistory `json:"appStateHistory,omitempty"`
	// fetch data from the table in a streaming manner: "app_state_history"
	AppStateHistoryStream []*AppStateHistory `json:"appStateHistory_stream"`
	// An array relationship
	Apps []*Apps `json:"apps"`
	// fetch data from the table in a streaming manner: "apps"
	AppsStream []*Apps `json:"apps_stream"`
	// fetch data from the table: "auth.refresh_tokens" using primary key columns
	AuthRefreshToken *AuthRefreshTokens `json:"authRefreshToken,omitempty"`
	// fetch data from the table: "auth.refresh_tokens"
	AuthRefreshTokens []*AuthRefreshTokens `json:"authRefreshTokens"`
	// fetch data from the table in a streaming manner: "auth.refresh_tokens"
	AuthRefreshTokensStream []*AuthRefreshTokens `json:"authRefreshTokens_stream"`
	// fetch data from the table: "auth.user_providers" using primary key columns
	AuthUserProvider *AuthUserProviders `json:"authUserProvider,omitempty"`
	// fetch data from the table: "auth.user_providers"
	AuthUserProviders []*AuthUserProviders `json:"authUserProviders"`
	// fetch data from the table in a streaming manner: "auth.user_providers"
	AuthUserProvidersStream []*AuthUserProviders `json:"authUserProviders_stream"`
	// fetch data from the table: "backups" using primary key columns
	Backup *Backups `json:"backup,omitempty"`
	// An array relationship
	Backups []*Backups `json:"backups"`
	// fetch data from the table in a streaming manner: "backups"
	BackupsStream []*Backups `json:"backups_stream"`
	// fetch data from the table: "cli_tokens" using primary key columns
	CliToken *CliTokens `json:"cliToken,omitempty"`
	// An array relationship
	CliTokens []*CliTokens `json:"cliTokens"`
	// fetch data from the table in a streaming manner: "cli_tokens"
	CliTokensStream []*CliTokens `json:"cliTokens_stream"`
	// fetch data from the table: "continents"
	Continents []*Continents `json:"continents"`
	// fetch data from the table: "continents" using primary key columns
	ContinentsByPk *Continents `json:"continents_by_pk,omitempty"`
	// fetch data from the table in a streaming manner: "continents"
	ContinentsStream []*Continents `json:"continents_stream"`
	// An array relationship
	Countries []*Countries `json:"countries"`
	// fetch data from the table: "countries" using primary key columns
	CountriesByPk *Countries `json:"countries_by_pk,omitempty"`
	// fetch data from the table in a streaming manner: "countries"
	CountriesStream []*Countries `json:"countries_stream"`
	// fetch data from the table: "deployments" using primary key columns
	Deployment *Deployments `json:"deployment,omitempty"`
	// fetch data from the table: "deployment_logs" using primary key columns
	DeploymentLog *DeploymentLogs `json:"deploymentLog,omitempty"`
	// An array relationship
	DeploymentLogs []*DeploymentLogs `json:"deploymentLogs"`
	// fetch data from the table in a streaming manner: "deployment_logs"
	DeploymentLogsStream []*DeploymentLogs `json:"deploymentLogs_stream"`
	// An array relationship
	Deployments []*Deployments `json:"deployments"`
	// fetch data from the table in a streaming manner: "deployments"
	DeploymentsStream []*Deployments `json:"deployments_stream"`
	// fetch data from the table: "feature_flags" using primary key columns
	FeatureFlag *FeatureFlags `json:"featureFlag,omitempty"`
	// An array relationship
	FeatureFlags []*FeatureFlags `json:"featureFlags"`
	// fetch data from the table in a streaming manner: "feature_flags"
	FeatureFlagsStream []*FeatureFlags `json:"featureFlags_stream"`
	// fetch data from the table: "github_app_installations" using primary key columns
	GithubAppInstallation *GithubAppInstallations `json:"githubAppInstallation,omitempty"`
	// fetch data from the table: "github_app_installations"
	GithubAppInstallations []*GithubAppInstallations `json:"githubAppInstallations"`
	// fetch data from the table in a streaming manner: "github_app_installations"
	GithubAppInstallationsStream []*GithubAppInstallations `json:"githubAppInstallations_stream"`
	// An array relationship
	GithubRepositories []*GithubRepositories `json:"githubRepositories"`
	// fetch data from the table in a streaming manner: "github_repositories"
	GithubRepositoriesStream []*GithubRepositories `json:"githubRepositories_stream"`
	// fetch data from the table: "github_repositories" using primary key columns
	GithubRepository *GithubRepositories `json:"githubRepository,omitempty"`
	// fetch data from the table: "payment_methods" using primary key columns
	PaymentMethod *PaymentMethods `json:"paymentMethod,omitempty"`
	// An array relationship
	PaymentMethods []*PaymentMethods `json:"paymentMethods"`
	// fetch data from the table in a streaming manner: "payment_methods"
	PaymentMethodsStream []*PaymentMethods `json:"paymentMethods_stream"`
	// fetch data from the table: "plans" using primary key columns
	Plan *Plans `json:"plan,omitempty"`
	// fetch data from the table: "plans"
	Plans []*Plans `json:"plans"`
	// fetch data from the table in a streaming manner: "plans"
	PlansStream []*Plans `json:"plans_stream"`
	// fetch data from the table: "regions"
	Regions []*Regions `json:"regions"`
	// fetch data from the table in a streaming manner: "regions_allowed_workspace"
	RegionsAllowedWorkspaceStream []*RegionsAllowedWorkspace `json:"regions_allowed_workspace_stream"`
	// fetch data from the table: "regions" using primary key columns
	RegionsByPk *Regions `json:"regions_by_pk,omitempty"`
	// fetch data from the table in a streaming manner: "regions"
	RegionsStream []*Regions `json:"regions_stream"`
	// fetch data from the table: "run_service" using primary key columns
	RunService *RunService `json:"runService,omitempty"`
	// An array relationship
	RunServices []*RunService `json:"runServices"`
	// fetch aggregated fields from the table: "run_service"
	RunServicesAggregate *RunServiceAggregate `json:"runServicesAggregate"`
	// fetch data from the table in a streaming manner: "run_service"
	RunServiceStream []*RunService `json:"run_service_stream"`
	// fetch data from the table: "regions_allowed_workspace" using primary key columns
	SelectRegionsAllowedWorkspace *RegionsAllowedWorkspace `json:"selectRegionsAllowedWorkspace,omitempty"`
	// fetch data from the table: "regions_allowed_workspace"
	SelectRegionsAllowedWorkspaces []*RegionsAllowedWorkspace `json:"selectRegionsAllowedWorkspaces"`
	// fetch data from the table: "software_versions" using primary key columns
	SoftwareVersion *SoftwareVersions `json:"softwareVersion,omitempty"`
	// fetch data from the table: "software_versions"
	SoftwareVersions []*SoftwareVersions `json:"softwareVersions"`
	// fetch data from the table in a streaming manner: "software_versions"
	SoftwareVersionsStream []*SoftwareVersions `json:"softwareVersionsStream"`
	// fetch data from the table: "auth.users" using primary key columns
	User *Users `json:"user,omitempty"`
	// fetch data from the table: "auth.users"
	Users []*Users `json:"users"`
	// fetch data from the table: "users_usage" using primary key columns
	UsersUsage *UsersUsage `json:"usersUsage,omitempty"`
	// fetch data from the table: "users_usage"
	UsersUsages []*UsersUsage `json:"usersUsages"`
	// fetch data from the table in a streaming manner: "auth.users"
	UsersStream []*Users `json:"users_stream"`
	// fetch data from the table in a streaming manner: "users_usage"
	UsersUsageStream []*UsersUsage `json:"users_usage_stream"`
	// fetch data from the table: "workspaces" using primary key columns
	Workspace *Workspaces `json:"workspace,omitempty"`
	// fetch data from the table: "workspace_members" using primary key columns
	WorkspaceMember *WorkspaceMembers `json:"workspaceMember,omitempty"`
	// fetch data from the table: "workspace_member_invites" using primary key columns
	WorkspaceMemberInvite *WorkspaceMemberInvites `json:"workspaceMemberInvite,omitempty"`
	// An array relationship
	WorkspaceMemberInvites []*WorkspaceMemberInvites `json:"workspaceMemberInvites"`
	// fetch data from the table in a streaming manner: "workspace_member_invites"
	WorkspaceMemberInvitesStream []*WorkspaceMemberInvites `json:"workspaceMemberInvites_stream"`
	// An array relationship
	WorkspaceMembers []*WorkspaceMembers `json:"workspaceMembers"`
	// fetch data from the table in a streaming manner: "workspace_members"
	WorkspaceMembersStream []*WorkspaceMembers `json:"workspaceMembers_stream"`
	// An array relationship
	Workspaces []*Workspaces `json:"workspaces"`
	// fetch data from the table in a streaming manner: "workspaces"
	WorkspacesStream []*Workspaces `json:"workspaces_stream"`
}

type TimestamptzComparisonExp 

type TimestamptzComparisonExp struct {
	Eq     *time.Time   `json:"_eq,omitempty"`
	Gt     *time.Time   `json:"_gt,omitempty"`
	Gte    *time.Time   `json:"_gte,omitempty"`
	In     []*time.Time `json:"_in,omitempty"`
	IsNull *bool        `json:"_is_null,omitempty"`
	Lt     *time.Time   `json:"_lt,omitempty"`
	Lte    *time.Time   `json:"_lte,omitempty"`
	Neq    *time.Time   `json:"_neq,omitempty"`
	Nin    []*time.Time `json:"_nin,omitempty"`
}

Boolean expression to compare columns of type "timestamptz". All fields are combined with logical 'AND'.

type UUIDComparisonExp 

type UUIDComparisonExp struct {
	Eq     *string  `json:"_eq,omitempty"`
	Gt     *string  `json:"_gt,omitempty"`
	Gte    *string  `json:"_gte,omitempty"`
	In     []string `json:"_in,omitempty"`
	IsNull *bool    `json:"_is_null,omitempty"`
	Lt     *string  `json:"_lt,omitempty"`
	Lte    *string  `json:"_lte,omitempty"`
	Neq    *string  `json:"_neq,omitempty"`
	Nin    []string `json:"_nin,omitempty"`
}

Boolean expression to compare columns of type "uuid". All fields are combined with logical 'AND'.

type UpdateRunServiceConfig added in v1.5.0 

type UpdateRunServiceConfig struct {
	UpdateRunServiceConfig UpdateRunServiceConfig_UpdateRunServiceConfig "json:\"updateRunServiceConfig\" graphql:\"updateRunServiceConfig\""
}

func (*UpdateRunServiceConfig) GetUpdateRunServiceConfig added in v1.5.0 

func (t *UpdateRunServiceConfig) GetUpdateRunServiceConfig() *UpdateRunServiceConfig_UpdateRunServiceConfig

type UpdateRunServiceConfig_UpdateRunServiceConfig added in v1.5.0 

type UpdateRunServiceConfig_UpdateRunServiceConfig struct {
	Typename *string "json:\"__typename,omitempty\" graphql:\"__typename\""
}

func (*UpdateRunServiceConfig_UpdateRunServiceConfig) GetTypename added in v1.5.0 

func (t *UpdateRunServiceConfig_UpdateRunServiceConfig) GetTypename() *string

type UpdateSecret 

type UpdateSecret struct {
	UpdateSecret UpdateSecret_UpdateSecret "json:\"updateSecret\" graphql:\"updateSecret\""
}

func (*UpdateSecret) GetUpdateSecret 

func (t *UpdateSecret) GetUpdateSecret() *UpdateSecret_UpdateSecret

type UpdateSecret_UpdateSecret 

type UpdateSecret_UpdateSecret struct {
	Name  string "json:\"name\" graphql:\"name\""
	Value string "json:\"value\" graphql:\"value\""
}

func (*UpdateSecret_UpdateSecret) GetName 

func (t *UpdateSecret_UpdateSecret) GetName() string

func (*UpdateSecret_UpdateSecret) GetValue 

func (t *UpdateSecret_UpdateSecret) GetValue() string

type Users 

type Users struct {
	// An array relationship
	Apps      []*Apps `json:"apps"`
	AvatarURL string  `json:"avatarUrl"`
	// An array relationship
	CliTokens []*CliTokens `json:"cliTokens"`
	// An array relationship
	CreatorOfWorkspaces []*Workspaces `json:"creatorOfWorkspaces"`
	DisplayName         string        `json:"displayName"`
	Email               *string       `json:"email,omitempty"`
	// An array relationship
	GithubAppInstallations []*GithubAppInstallations `json:"github_app_installations"`
	ID                     string                    `json:"id"`
	// An array relationship
	PaymentMethods []*PaymentMethods `json:"payment_methods"`
	// An array relationship
	RefreshTokens []*AuthRefreshTokens `json:"refreshTokens"`
	// An array relationship
	RunServices []*RunService `json:"runServices"`
	// An aggregate relationship
	RunServicesAggregate *RunServiceAggregate `json:"runServices_aggregate"`
	// An array relationship
	UserProviders []*AuthUserProviders `json:"userProviders"`
	// An array relationship
	WorkspaceMemberInvitesByInvitedByUserID []*WorkspaceMemberInvites `json:"workspaceMemberInvitesByInvitedByUserId"`
	// An array relationship
	WorkspaceMembers []*WorkspaceMembers `json:"workspaceMembers"`
	// An array relationship
	WorkspaceMemberInvites []*WorkspaceMemberInvites `json:"workspace_member_invites"`
}

User account information. Don't modify its structure as Hasura Auth relies on it to function properly.

type UsersBoolExp 

type UsersBoolExp struct {
	And                                     []*UsersBoolExp                `json:"_and,omitempty"`
	Not                                     *UsersBoolExp                  `json:"_not,omitempty"`
	Or                                      []*UsersBoolExp                `json:"_or,omitempty"`
	Apps                                    *AppsBoolExp                   `json:"apps,omitempty"`
	AvatarURL                               *StringComparisonExp           `json:"avatarUrl,omitempty"`
	CliTokens                               *CliTokensBoolExp              `json:"cliTokens,omitempty"`
	CreatorOfWorkspaces                     *WorkspacesBoolExp             `json:"creatorOfWorkspaces,omitempty"`
	DisplayName                             *StringComparisonExp           `json:"displayName,omitempty"`
	Email                                   *CitextComparisonExp           `json:"email,omitempty"`
	GithubAppInstallations                  *GithubAppInstallationsBoolExp `json:"github_app_installations,omitempty"`
	ID                                      *UUIDComparisonExp             `json:"id,omitempty"`
	PaymentMethods                          *PaymentMethodsBoolExp         `json:"payment_methods,omitempty"`
	RefreshTokens                           *AuthRefreshTokensBoolExp      `json:"refreshTokens,omitempty"`
	RunServices                             *RunServiceBoolExp             `json:"runServices,omitempty"`
	RunServicesAggregate                    *RunServiceAggregateBoolExp    `json:"runServices_aggregate,omitempty"`
	UserProviders                           *AuthUserProvidersBoolExp      `json:"userProviders,omitempty"`
	WorkspaceMemberInvitesByInvitedByUserID *WorkspaceMemberInvitesBoolExp `json:"workspaceMemberInvitesByInvitedByUserId,omitempty"`
	WorkspaceMembers                        *WorkspaceMembersBoolExp       `json:"workspaceMembers,omitempty"`
	WorkspaceMemberInvites                  *WorkspaceMemberInvitesBoolExp `json:"workspace_member_invites,omitempty"`
}

Boolean expression to filter rows from the table "auth.users". All fields are combined with a logical 'AND'.

type UsersMutationResponse 

type UsersMutationResponse struct {
	// number of rows affected by the mutation
	AffectedRows int64 `json:"affected_rows"`
	// data from the rows affected by the mutation
	Returning []*Users `json:"returning"`
}

response of any mutation on the table "auth.users"

type UsersOrderBy 

type UsersOrderBy struct {
	AppsAggregate                                    *AppsAggregateOrderBy                   `json:"apps_aggregate,omitempty"`
	AvatarURL                                        *OrderBy                                `json:"avatarUrl,omitempty"`
	CliTokensAggregate                               *CliTokensAggregateOrderBy              `json:"cliTokens_aggregate,omitempty"`
	CreatorOfWorkspacesAggregate                     *WorkspacesAggregateOrderBy             `json:"creatorOfWorkspaces_aggregate,omitempty"`
	DisplayName                                      *OrderBy                                `json:"displayName,omitempty"`
	Email                                            *OrderBy                                `json:"email,omitempty"`
	GithubAppInstallationsAggregate                  *GithubAppInstallationsAggregateOrderBy `json:"github_app_installations_aggregate,omitempty"`
	ID                                               *OrderBy                                `json:"id,omitempty"`
	PaymentMethodsAggregate                          *PaymentMethodsAggregateOrderBy         `json:"payment_methods_aggregate,omitempty"`
	RefreshTokensAggregate                           *AuthRefreshTokensAggregateOrderBy      `json:"refreshTokens_aggregate,omitempty"`
	RunServicesAggregate                             *RunServiceAggregateOrderBy             `json:"runServices_aggregate,omitempty"`
	UserProvidersAggregate                           *AuthUserProvidersAggregateOrderBy      `json:"userProviders_aggregate,omitempty"`
	WorkspaceMemberInvitesByInvitedByUserIDAggregate *WorkspaceMemberInvitesAggregateOrderBy `json:"workspaceMemberInvitesByInvitedByUserId_aggregate,omitempty"`
	WorkspaceMembersAggregate                        *WorkspaceMembersAggregateOrderBy       `json:"workspaceMembers_aggregate,omitempty"`
	WorkspaceMemberInvitesAggregate                  *WorkspaceMemberInvitesAggregateOrderBy `json:"workspace_member_invites_aggregate,omitempty"`
}

Ordering options when selecting data from "auth.users".

type UsersPkColumnsInput 

type UsersPkColumnsInput struct {
	ID string `json:"id"`
}

primary key columns input for table: auth.users

type UsersSelectColumn 

type UsersSelectColumn string

select columns of table "auth.users" 

const (
	// column name
	UsersSelectColumnAvatarURL UsersSelectColumn = "avatarUrl"
	// column name
	UsersSelectColumnDisplayName UsersSelectColumn = "displayName"
	// column name
	UsersSelectColumnEmail UsersSelectColumn = "email"
	// column name
	UsersSelectColumnID UsersSelectColumn = "id"
)

func (UsersSelectColumn) IsValid 

func (e UsersSelectColumn) IsValid() bool

func (UsersSelectColumn) MarshalGQL 

func (e UsersSelectColumn) MarshalGQL(w io.Writer)

func (UsersSelectColumn) String 

func (e UsersSelectColumn) String() string

func (*UsersSelectColumn) UnmarshalGQL 

func (e *UsersSelectColumn) UnmarshalGQL(v interface{}) error

type UsersSetInput 

type UsersSetInput struct {
	DisplayName *string `json:"displayName,omitempty"`
}

input type for updating data in table "auth.users"

type UsersStreamCursorInput 

type UsersStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *UsersStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "users"

type UsersStreamCursorValueInput 

type UsersStreamCursorValueInput struct {
	AvatarURL   *string `json:"avatarUrl,omitempty"`
	DisplayName *string `json:"displayName,omitempty"`
	Email       *string `json:"email,omitempty"`
	ID          *string `json:"id,omitempty"`
}

Initial value of the column from where the streaming should start

type UsersUpdates 

type UsersUpdates struct {
	// sets the columns of the filtered rows to the given values
	Set *UsersSetInput `json:"_set,omitempty"`
	// filter the rows which have to be updated
	Where *UsersBoolExp `json:"where"`
}

type UsersUsage added in v1.9.3 

type UsersUsage struct {
	CreatedAt             time.Time `json:"created_at"`
	FreeAllowanceExceeded bool      `json:"free_allowance_exceeded"`
	ID                    string    `json:"id"`
	UpdatedAt             time.Time `json:"updated_at"`
	UserID                string    `json:"user_id"`
}

columns and relationships of "users_usage"

type UsersUsageBoolExp added in v1.9.3 

type UsersUsageBoolExp struct {
	And                   []*UsersUsageBoolExp      `json:"_and,omitempty"`
	Not                   *UsersUsageBoolExp        `json:"_not,omitempty"`
	Or                    []*UsersUsageBoolExp      `json:"_or,omitempty"`
	CreatedAt             *TimestamptzComparisonExp `json:"created_at,omitempty"`
	FreeAllowanceExceeded *BooleanComparisonExp     `json:"free_allowance_exceeded,omitempty"`
	ID                    *UUIDComparisonExp        `json:"id,omitempty"`
	UpdatedAt             *TimestamptzComparisonExp `json:"updated_at,omitempty"`
	UserID                *UUIDComparisonExp        `json:"user_id,omitempty"`
}

Boolean expression to filter rows from the table "users_usage". All fields are combined with a logical 'AND'.

type UsersUsageOrderBy added in v1.9.3 

type UsersUsageOrderBy struct {
	CreatedAt             *OrderBy `json:"created_at,omitempty"`
	FreeAllowanceExceeded *OrderBy `json:"free_allowance_exceeded,omitempty"`
	ID                    *OrderBy `json:"id,omitempty"`
	UpdatedAt             *OrderBy `json:"updated_at,omitempty"`
	UserID                *OrderBy `json:"user_id,omitempty"`
}

Ordering options when selecting data from "users_usage".

type UsersUsageSelectColumn added in v1.9.3 

type UsersUsageSelectColumn string

select columns of table "users_usage" 

const (
	// column name
	UsersUsageSelectColumnCreatedAt UsersUsageSelectColumn = "created_at"
	// column name
	UsersUsageSelectColumnFreeAllowanceExceeded UsersUsageSelectColumn = "free_allowance_exceeded"
	// column name
	UsersUsageSelectColumnID UsersUsageSelectColumn = "id"
	// column name
	UsersUsageSelectColumnUpdatedAt UsersUsageSelectColumn = "updated_at"
	// column name
	UsersUsageSelectColumnUserID UsersUsageSelectColumn = "user_id"
)

func (UsersUsageSelectColumn) IsValid added in v1.9.3 

func (e UsersUsageSelectColumn) IsValid() bool

func (UsersUsageSelectColumn) MarshalGQL added in v1.9.3 

func (e UsersUsageSelectColumn) MarshalGQL(w io.Writer)

func (UsersUsageSelectColumn) String added in v1.9.3 

func (e UsersUsageSelectColumn) String() string

func (*UsersUsageSelectColumn) UnmarshalGQL added in v1.9.3 

func (e *UsersUsageSelectColumn) UnmarshalGQL(v interface{}) error

type UsersUsageStreamCursorInput added in v1.9.3 

type UsersUsageStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *UsersUsageStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "users_usage"

type UsersUsageStreamCursorValueInput added in v1.9.3 

type UsersUsageStreamCursorValueInput struct {
	CreatedAt             *time.Time `json:"created_at,omitempty"`
	FreeAllowanceExceeded *bool      `json:"free_allowance_exceeded,omitempty"`
	ID                    *string    `json:"id,omitempty"`
	UpdatedAt             *time.Time `json:"updated_at,omitempty"`
	UserID                *string    `json:"user_id,omitempty"`
}

Initial value of the column from where the streaming should start

type WorkspaceMemberInvites 

type WorkspaceMemberInvites struct {
	CreatedAt time.Time `json:"createdAt"`
	Email     string    `json:"email"`
	ID        string    `json:"id"`
	// An object relationship
	InvitedByUser   *Users `json:"invitedByUser"`
	InvitedByUserID string `json:"invitedByUserId"`
	// owner or member
	MemberType string    `json:"memberType"`
	UpdatedAt  time.Time `json:"updatedAt"`
	// An object relationship
	UserByEmail *Users `json:"userByEmail,omitempty"`
	// An object relationship
	Workspace   *Workspaces `json:"workspace"`
	WorkspaceID string      `json:"workspaceId"`
}

columns and relationships of "workspace_member_invites"

type WorkspaceMemberInvitesAggregateOrderBy 

type WorkspaceMemberInvitesAggregateOrderBy struct {
	Count *OrderBy                          `json:"count,omitempty"`
	Max   *WorkspaceMemberInvitesMaxOrderBy `json:"max,omitempty"`
	Min   *WorkspaceMemberInvitesMinOrderBy `json:"min,omitempty"`
}

order by aggregate values of table "workspace_member_invites"

type WorkspaceMemberInvitesArrRelInsertInput 

type WorkspaceMemberInvitesArrRelInsertInput struct {
	Data []*WorkspaceMemberInvitesInsertInput `json:"data"`
	// upsert condition
	OnConflict *WorkspaceMemberInvitesOnConflict `json:"on_conflict,omitempty"`
}

input type for inserting array relation for remote table "workspace_member_invites"

type WorkspaceMemberInvitesBoolExp 

type WorkspaceMemberInvitesBoolExp struct {
	And             []*WorkspaceMemberInvitesBoolExp `json:"_and,omitempty"`
	Not             *WorkspaceMemberInvitesBoolExp   `json:"_not,omitempty"`
	Or              []*WorkspaceMemberInvitesBoolExp `json:"_or,omitempty"`
	CreatedAt       *TimestamptzComparisonExp        `json:"createdAt,omitempty"`
	Email           *CitextComparisonExp             `json:"email,omitempty"`
	ID              *UUIDComparisonExp               `json:"id,omitempty"`
	InvitedByUser   *UsersBoolExp                    `json:"invitedByUser,omitempty"`
	InvitedByUserID *UUIDComparisonExp               `json:"invitedByUserId,omitempty"`
	MemberType      *StringComparisonExp             `json:"memberType,omitempty"`
	UpdatedAt       *TimestamptzComparisonExp        `json:"updatedAt,omitempty"`
	UserByEmail     *UsersBoolExp                    `json:"userByEmail,omitempty"`
	Workspace       *WorkspacesBoolExp               `json:"workspace,omitempty"`
	WorkspaceID     *UUIDComparisonExp               `json:"workspaceId,omitempty"`
}

Boolean expression to filter rows from the table "workspace_member_invites". All fields are combined with a logical 'AND'.

type WorkspaceMemberInvitesConstraint 

type WorkspaceMemberInvitesConstraint string

unique or primary key constraints on table "workspace_member_invites" 

const (
	// unique or primary key constraint on columns "workspace_id", "email"
	WorkspaceMemberInvitesConstraintWorkspaceMemberInvitesEmailWorkspaceIDKey WorkspaceMemberInvitesConstraint = "workspace_member_invites_email_workspace_id_key"
	// unique or primary key constraint on columns "id"
	WorkspaceMemberInvitesConstraintWorkspaceMemberInvitesPkey WorkspaceMemberInvitesConstraint = "workspace_member_invites_pkey"
)

func (WorkspaceMemberInvitesConstraint) IsValid 

func (e WorkspaceMemberInvitesConstraint) IsValid() bool

func (WorkspaceMemberInvitesConstraint) MarshalGQL 

func (e WorkspaceMemberInvitesConstraint) MarshalGQL(w io.Writer)

func (WorkspaceMemberInvitesConstraint) String 

func (e WorkspaceMemberInvitesConstraint) String() string

func (*WorkspaceMemberInvitesConstraint) UnmarshalGQL 

func (e *WorkspaceMemberInvitesConstraint) UnmarshalGQL(v interface{}) error

type WorkspaceMemberInvitesInsertInput 

type WorkspaceMemberInvitesInsertInput struct {
	Email *string `json:"email,omitempty"`
	// owner or member
	MemberType  *string                      `json:"memberType,omitempty"`
	Workspace   *WorkspacesObjRelInsertInput `json:"workspace,omitempty"`
	WorkspaceID *string                      `json:"workspaceId,omitempty"`
}

input type for inserting data into table "workspace_member_invites"

type WorkspaceMemberInvitesMaxOrderBy 

type WorkspaceMemberInvitesMaxOrderBy struct {
	CreatedAt       *OrderBy `json:"createdAt,omitempty"`
	Email           *OrderBy `json:"email,omitempty"`
	ID              *OrderBy `json:"id,omitempty"`
	InvitedByUserID *OrderBy `json:"invitedByUserId,omitempty"`
	// owner or member
	MemberType  *OrderBy `json:"memberType,omitempty"`
	UpdatedAt   *OrderBy `json:"updatedAt,omitempty"`
	WorkspaceID *OrderBy `json:"workspaceId,omitempty"`
}

order by max() on columns of table "workspace_member_invites"

type WorkspaceMemberInvitesMinOrderBy 

type WorkspaceMemberInvitesMinOrderBy struct {
	CreatedAt       *OrderBy `json:"createdAt,omitempty"`
	Email           *OrderBy `json:"email,omitempty"`
	ID              *OrderBy `json:"id,omitempty"`
	InvitedByUserID *OrderBy `json:"invitedByUserId,omitempty"`
	// owner or member
	MemberType  *OrderBy `json:"memberType,omitempty"`
	UpdatedAt   *OrderBy `json:"updatedAt,omitempty"`
	WorkspaceID *OrderBy `json:"workspaceId,omitempty"`
}

order by min() on columns of table "workspace_member_invites"

type WorkspaceMemberInvitesMutationResponse 

type WorkspaceMemberInvitesMutationResponse struct {
	// number of rows affected by the mutation
	AffectedRows int64 `json:"affected_rows"`
	// data from the rows affected by the mutation
	Returning []*WorkspaceMemberInvites `json:"returning"`
}

response of any mutation on the table "workspace_member_invites"

type WorkspaceMemberInvitesOnConflict 

type WorkspaceMemberInvitesOnConflict struct {
	Constraint    WorkspaceMemberInvitesConstraint     `json:"constraint"`
	UpdateColumns []WorkspaceMemberInvitesUpdateColumn `json:"update_columns"`
	Where         *WorkspaceMemberInvitesBoolExp       `json:"where,omitempty"`
}

on_conflict condition type for table "workspace_member_invites"

type WorkspaceMemberInvitesOrderBy 

type WorkspaceMemberInvitesOrderBy struct {
	CreatedAt       *OrderBy           `json:"createdAt,omitempty"`
	Email           *OrderBy           `json:"email,omitempty"`
	ID              *OrderBy           `json:"id,omitempty"`
	InvitedByUser   *UsersOrderBy      `json:"invitedByUser,omitempty"`
	InvitedByUserID *OrderBy           `json:"invitedByUserId,omitempty"`
	MemberType      *OrderBy           `json:"memberType,omitempty"`
	UpdatedAt       *OrderBy           `json:"updatedAt,omitempty"`
	UserByEmail     *UsersOrderBy      `json:"userByEmail,omitempty"`
	Workspace       *WorkspacesOrderBy `json:"workspace,omitempty"`
	WorkspaceID     *OrderBy           `json:"workspaceId,omitempty"`
}

Ordering options when selecting data from "workspace_member_invites".

type WorkspaceMemberInvitesPkColumnsInput 

type WorkspaceMemberInvitesPkColumnsInput struct {
	ID string `json:"id"`
}

primary key columns input for table: workspace_member_invites

type WorkspaceMemberInvitesSelectColumn 

type WorkspaceMemberInvitesSelectColumn string

select columns of table "workspace_member_invites" 

const (
	// column name
	WorkspaceMemberInvitesSelectColumnCreatedAt WorkspaceMemberInvitesSelectColumn = "createdAt"
	// column name
	WorkspaceMemberInvitesSelectColumnEmail WorkspaceMemberInvitesSelectColumn = "email"
	// column name
	WorkspaceMemberInvitesSelectColumnID WorkspaceMemberInvitesSelectColumn = "id"
	// column name
	WorkspaceMemberInvitesSelectColumnInvitedByUserID WorkspaceMemberInvitesSelectColumn = "invitedByUserId"
	// column name
	WorkspaceMemberInvitesSelectColumnMemberType WorkspaceMemberInvitesSelectColumn = "memberType"
	// column name
	WorkspaceMemberInvitesSelectColumnUpdatedAt WorkspaceMemberInvitesSelectColumn = "updatedAt"
	// column name
	WorkspaceMemberInvitesSelectColumnWorkspaceID WorkspaceMemberInvitesSelectColumn = "workspaceId"
)

func (WorkspaceMemberInvitesSelectColumn) IsValid 

func (e WorkspaceMemberInvitesSelectColumn) IsValid() bool

func (WorkspaceMemberInvitesSelectColumn) MarshalGQL 

func (e WorkspaceMemberInvitesSelectColumn) MarshalGQL(w io.Writer)

func (WorkspaceMemberInvitesSelectColumn) String 

func (e WorkspaceMemberInvitesSelectColumn) String() string

func (*WorkspaceMemberInvitesSelectColumn) UnmarshalGQL 

func (e *WorkspaceMemberInvitesSelectColumn) UnmarshalGQL(v interface{}) error

type WorkspaceMemberInvitesSetInput 

type WorkspaceMemberInvitesSetInput struct {
	// owner or member
	MemberType *string `json:"memberType,omitempty"`
}

input type for updating data in table "workspace_member_invites"

type WorkspaceMemberInvitesStreamCursorInput 

type WorkspaceMemberInvitesStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *WorkspaceMemberInvitesStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "workspaceMemberInvites"

type WorkspaceMemberInvitesStreamCursorValueInput 

type WorkspaceMemberInvitesStreamCursorValueInput struct {
	CreatedAt       *time.Time `json:"createdAt,omitempty"`
	Email           *string    `json:"email,omitempty"`
	ID              *string    `json:"id,omitempty"`
	InvitedByUserID *string    `json:"invitedByUserId,omitempty"`
	// owner or member
	MemberType  *string    `json:"memberType,omitempty"`
	UpdatedAt   *time.Time `json:"updatedAt,omitempty"`
	WorkspaceID *string    `json:"workspaceId,omitempty"`
}

Initial value of the column from where the streaming should start

type WorkspaceMemberInvitesUpdateColumn 

type WorkspaceMemberInvitesUpdateColumn string

update columns of table "workspace_member_invites" 

const (
	// column name
	WorkspaceMemberInvitesUpdateColumnMemberType WorkspaceMemberInvitesUpdateColumn = "memberType"
)

func (WorkspaceMemberInvitesUpdateColumn) IsValid 

func (e WorkspaceMemberInvitesUpdateColumn) IsValid() bool

func (WorkspaceMemberInvitesUpdateColumn) MarshalGQL 

func (e WorkspaceMemberInvitesUpdateColumn) MarshalGQL(w io.Writer)

func (WorkspaceMemberInvitesUpdateColumn) String 

func (e WorkspaceMemberInvitesUpdateColumn) String() string

func (*WorkspaceMemberInvitesUpdateColumn) UnmarshalGQL 

func (e *WorkspaceMemberInvitesUpdateColumn) UnmarshalGQL(v interface{}) error

type WorkspaceMemberInvitesUpdates 

type WorkspaceMemberInvitesUpdates struct {
	// sets the columns of the filtered rows to the given values
	Set *WorkspaceMemberInvitesSetInput `json:"_set,omitempty"`
	// filter the rows which have to be updated
	Where *WorkspaceMemberInvitesBoolExp `json:"where"`
}

type WorkspaceMembers 

type WorkspaceMembers struct {
	CreatedAt time.Time `json:"createdAt"`
	ID        string    `json:"id"`
	// owner or member
	Type      string    `json:"type"`
	UpdatedAt time.Time `json:"updatedAt"`
	// An object relationship
	User   *Users `json:"user"`
	UserID string `json:"userId"`
	// An object relationship
	Workspace   *Workspaces `json:"workspace"`
	WorkspaceID string      `json:"workspaceId"`
}

columns and relationships of "workspace_members"

type WorkspaceMembersAggregateOrderBy 

type WorkspaceMembersAggregateOrderBy struct {
	Count *OrderBy                    `json:"count,omitempty"`
	Max   *WorkspaceMembersMaxOrderBy `json:"max,omitempty"`
	Min   *WorkspaceMembersMinOrderBy `json:"min,omitempty"`
}

order by aggregate values of table "workspace_members"

type WorkspaceMembersArrRelInsertInput 

type WorkspaceMembersArrRelInsertInput struct {
	Data []*WorkspaceMembersInsertInput `json:"data"`
	// upsert condition
	OnConflict *WorkspaceMembersOnConflict `json:"on_conflict,omitempty"`
}

input type for inserting array relation for remote table "workspace_members"

type WorkspaceMembersBoolExp 

type WorkspaceMembersBoolExp struct {
	And         []*WorkspaceMembersBoolExp `json:"_and,omitempty"`
	Not         *WorkspaceMembersBoolExp   `json:"_not,omitempty"`
	Or          []*WorkspaceMembersBoolExp `json:"_or,omitempty"`
	CreatedAt   *TimestamptzComparisonExp  `json:"createdAt,omitempty"`
	ID          *UUIDComparisonExp         `json:"id,omitempty"`
	Type        *StringComparisonExp       `json:"type,omitempty"`
	UpdatedAt   *TimestamptzComparisonExp  `json:"updatedAt,omitempty"`
	User        *UsersBoolExp              `json:"user,omitempty"`
	UserID      *UUIDComparisonExp         `json:"userId,omitempty"`
	Workspace   *WorkspacesBoolExp         `json:"workspace,omitempty"`
	WorkspaceID *UUIDComparisonExp         `json:"workspaceId,omitempty"`
}

Boolean expression to filter rows from the table "workspace_members". All fields are combined with a logical 'AND'.

type WorkspaceMembersConstraint 

type WorkspaceMembersConstraint string

unique or primary key constraints on table "workspace_members" 

const (
	// unique or primary key constraint on columns "id"
	WorkspaceMembersConstraintWorkspaceMembersPkey WorkspaceMembersConstraint = "workspace_members_pkey"
	// unique or primary key constraint on columns "workspace_id", "user_id"
	WorkspaceMembersConstraintWorkspaceMembersUserIDWorkspaceIDKey WorkspaceMembersConstraint = "workspace_members_user_id_workspace_id_key"
)

func (WorkspaceMembersConstraint) IsValid 

func (e WorkspaceMembersConstraint) IsValid() bool

func (WorkspaceMembersConstraint) MarshalGQL 

func (e WorkspaceMembersConstraint) MarshalGQL(w io.Writer)

func (WorkspaceMembersConstraint) String 

func (e WorkspaceMembersConstraint) String() string

func (*WorkspaceMembersConstraint) UnmarshalGQL 

func (e *WorkspaceMembersConstraint) UnmarshalGQL(v interface{}) error

type WorkspaceMembersInsertInput 

type WorkspaceMembersInsertInput struct {
	// owner or member
	Type      *string                      `json:"type,omitempty"`
	UserID    *string                      `json:"userId,omitempty"`
	Workspace *WorkspacesObjRelInsertInput `json:"workspace,omitempty"`
}

input type for inserting data into table "workspace_members"

type WorkspaceMembersMaxOrderBy 

type WorkspaceMembersMaxOrderBy struct {
	CreatedAt *OrderBy `json:"createdAt,omitempty"`
	ID        *OrderBy `json:"id,omitempty"`
	// owner or member
	Type        *OrderBy `json:"type,omitempty"`
	UpdatedAt   *OrderBy `json:"updatedAt,omitempty"`
	UserID      *OrderBy `json:"userId,omitempty"`
	WorkspaceID *OrderBy `json:"workspaceId,omitempty"`
}

order by max() on columns of table "workspace_members"

type WorkspaceMembersMinOrderBy 

type WorkspaceMembersMinOrderBy struct {
	CreatedAt *OrderBy `json:"createdAt,omitempty"`
	ID        *OrderBy `json:"id,omitempty"`
	// owner or member
	Type        *OrderBy `json:"type,omitempty"`
	UpdatedAt   *OrderBy `json:"updatedAt,omitempty"`
	UserID      *OrderBy `json:"userId,omitempty"`
	WorkspaceID *OrderBy `json:"workspaceId,omitempty"`
}

order by min() on columns of table "workspace_members"

type WorkspaceMembersMutationResponse 

type WorkspaceMembersMutationResponse struct {
	// number of rows affected by the mutation
	AffectedRows int64 `json:"affected_rows"`
	// data from the rows affected by the mutation
	Returning []*WorkspaceMembers `json:"returning"`
}

response of any mutation on the table "workspace_members"

type WorkspaceMembersOnConflict 

type WorkspaceMembersOnConflict struct {
	Constraint    WorkspaceMembersConstraint     `json:"constraint"`
	UpdateColumns []WorkspaceMembersUpdateColumn `json:"update_columns"`
	Where         *WorkspaceMembersBoolExp       `json:"where,omitempty"`
}

on_conflict condition type for table "workspace_members"

type WorkspaceMembersOrderBy 

type WorkspaceMembersOrderBy struct {
	CreatedAt   *OrderBy           `json:"createdAt,omitempty"`
	ID          *OrderBy           `json:"id,omitempty"`
	Type        *OrderBy           `json:"type,omitempty"`
	UpdatedAt   *OrderBy           `json:"updatedAt,omitempty"`
	User        *UsersOrderBy      `json:"user,omitempty"`
	UserID      *OrderBy           `json:"userId,omitempty"`
	Workspace   *WorkspacesOrderBy `json:"workspace,omitempty"`
	WorkspaceID *OrderBy           `json:"workspaceId,omitempty"`
}

Ordering options when selecting data from "workspace_members".

type WorkspaceMembersPkColumnsInput 

type WorkspaceMembersPkColumnsInput struct {
	ID string `json:"id"`
}

primary key columns input for table: workspace_members

type WorkspaceMembersSelectColumn 

type WorkspaceMembersSelectColumn string

select columns of table "workspace_members" 

const (
	// column name
	WorkspaceMembersSelectColumnCreatedAt WorkspaceMembersSelectColumn = "createdAt"
	// column name
	WorkspaceMembersSelectColumnID WorkspaceMembersSelectColumn = "id"
	// column name
	WorkspaceMembersSelectColumnType WorkspaceMembersSelectColumn = "type"
	// column name
	WorkspaceMembersSelectColumnUpdatedAt WorkspaceMembersSelectColumn = "updatedAt"
	// column name
	WorkspaceMembersSelectColumnUserID WorkspaceMembersSelectColumn = "userId"
	// column name
	WorkspaceMembersSelectColumnWorkspaceID WorkspaceMembersSelectColumn = "workspaceId"
)

func (WorkspaceMembersSelectColumn) IsValid 

func (e WorkspaceMembersSelectColumn) IsValid() bool

func (WorkspaceMembersSelectColumn) MarshalGQL 

func (e WorkspaceMembersSelectColumn) MarshalGQL(w io.Writer)

func (WorkspaceMembersSelectColumn) String 

func (e WorkspaceMembersSelectColumn) String() string

func (*WorkspaceMembersSelectColumn) UnmarshalGQL 

func (e *WorkspaceMembersSelectColumn) UnmarshalGQL(v interface{}) error

type WorkspaceMembersSetInput 

type WorkspaceMembersSetInput struct {
	// owner or member
	Type *string `json:"type,omitempty"`
}

input type for updating data in table "workspace_members"

type WorkspaceMembersStreamCursorInput 

type WorkspaceMembersStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *WorkspaceMembersStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "workspaceMembers"

type WorkspaceMembersStreamCursorValueInput 

type WorkspaceMembersStreamCursorValueInput struct {
	CreatedAt *time.Time `json:"createdAt,omitempty"`
	ID        *string    `json:"id,omitempty"`
	// owner or member
	Type        *string    `json:"type,omitempty"`
	UpdatedAt   *time.Time `json:"updatedAt,omitempty"`
	UserID      *string    `json:"userId,omitempty"`
	WorkspaceID *string    `json:"workspaceId,omitempty"`
}

Initial value of the column from where the streaming should start

type WorkspaceMembersUpdateColumn 

type WorkspaceMembersUpdateColumn string

update columns of table "workspace_members" 

const (
	// column name
	WorkspaceMembersUpdateColumnType WorkspaceMembersUpdateColumn = "type"
)

func (WorkspaceMembersUpdateColumn) IsValid 

func (e WorkspaceMembersUpdateColumn) IsValid() bool

func (WorkspaceMembersUpdateColumn) MarshalGQL 

func (e WorkspaceMembersUpdateColumn) MarshalGQL(w io.Writer)

func (WorkspaceMembersUpdateColumn) String 

func (e WorkspaceMembersUpdateColumn) String() string

func (*WorkspaceMembersUpdateColumn) UnmarshalGQL 

func (e *WorkspaceMembersUpdateColumn) UnmarshalGQL(v interface{}) error

type WorkspaceMembersUpdates 

type WorkspaceMembersUpdates struct {
	// sets the columns of the filtered rows to the given values
	Set *WorkspaceMembersSetInput `json:"_set,omitempty"`
	// filter the rows which have to be updated
	Where *WorkspaceMembersBoolExp `json:"where"`
}

type Workspaces 

type Workspaces struct {
	// City, district, suburb, town, or village.
	AddressCity string `json:"addressCity"`
	// An object relationship
	AddressCountry *Countries `json:"addressCountry,omitempty"`
	// Two-letter country code (ISO 3166-1 alpha-2).
	AddressCountryCode *string `json:"addressCountryCode,omitempty"`
	// Address line 1 (e.g., street, PO Box, or company name).
	AddressLine1 string `json:"addressLine1"`
	// Address line 2 (e.g., apartment, suite, unit, or building).
	AddressLine2 string `json:"addressLine2"`
	// ZIP or postal code.
	AddressPostalCode string `json:"addressPostalCode"`
	// State, county, province, or region.
	AddressState string `json:"addressState"`
	// An object relationship
	AllowedPrivateRegions *RegionsAllowedWorkspace `json:"allowedPrivateRegions,omitempty"`
	// An array relationship
	Apps        []*Apps   `json:"apps"`
	CompanyName string    `json:"companyName"`
	CreatedAt   time.Time `json:"createdAt"`
	// An object relationship
	CreatorUser   *Users  `json:"creatorUser,omitempty"`
	CreatorUserID *string `json:"creatorUserId,omitempty"`
	Email         string  `json:"email"`
	ID            string  `json:"id"`
	Name          string  `json:"name"`
	// An object relationship
	PaymentMethod *PaymentMethods `json:"paymentMethod,omitempty"`
	// An array relationship
	PaymentMethods []*PaymentMethods `json:"paymentMethods"`
	// An array relationship
	RegionsAllowedWorkspaces []*RegionsAllowedWorkspace `json:"regions_allowed_workspaces"`
	Slug                     string                     `json:"slug"`
	TaxIDType                string                     `json:"taxIdType"`
	TaxIDValue               string                     `json:"taxIdValue"`
	UpdatedAt                time.Time                  `json:"updatedAt"`
	// An array relationship
	WorkspaceMemberInvites []*WorkspaceMemberInvites `json:"workspaceMemberInvites"`
	// An array relationship
	WorkspaceMembers []*WorkspaceMembers `json:"workspaceMembers"`
}

columns and relationships of "workspaces"

type WorkspacesAggregateOrderBy 

type WorkspacesAggregateOrderBy struct {
	Count *OrderBy              `json:"count,omitempty"`
	Max   *WorkspacesMaxOrderBy `json:"max,omitempty"`
	Min   *WorkspacesMinOrderBy `json:"min,omitempty"`
}

order by aggregate values of table "workspaces"

type WorkspacesBoolExp 

type WorkspacesBoolExp struct {
	And                      []*WorkspacesBoolExp            `json:"_and,omitempty"`
	Not                      *WorkspacesBoolExp              `json:"_not,omitempty"`
	Or                       []*WorkspacesBoolExp            `json:"_or,omitempty"`
	AddressCity              *StringComparisonExp            `json:"addressCity,omitempty"`
	AddressCountry           *CountriesBoolExp               `json:"addressCountry,omitempty"`
	AddressCountryCode       *StringComparisonExp            `json:"addressCountryCode,omitempty"`
	AddressLine1             *StringComparisonExp            `json:"addressLine1,omitempty"`
	AddressLine2             *StringComparisonExp            `json:"addressLine2,omitempty"`
	AddressPostalCode        *StringComparisonExp            `json:"addressPostalCode,omitempty"`
	AddressState             *StringComparisonExp            `json:"addressState,omitempty"`
	AllowedPrivateRegions    *RegionsAllowedWorkspaceBoolExp `json:"allowedPrivateRegions,omitempty"`
	Apps                     *AppsBoolExp                    `json:"apps,omitempty"`
	CompanyName              *StringComparisonExp            `json:"companyName,omitempty"`
	CreatedAt                *TimestamptzComparisonExp       `json:"createdAt,omitempty"`
	CreatorUser              *UsersBoolExp                   `json:"creatorUser,omitempty"`
	CreatorUserID            *UUIDComparisonExp              `json:"creatorUserId,omitempty"`
	Email                    *StringComparisonExp            `json:"email,omitempty"`
	ID                       *UUIDComparisonExp              `json:"id,omitempty"`
	Name                     *StringComparisonExp            `json:"name,omitempty"`
	PaymentMethod            *PaymentMethodsBoolExp          `json:"paymentMethod,omitempty"`
	PaymentMethods           *PaymentMethodsBoolExp          `json:"paymentMethods,omitempty"`
	RegionsAllowedWorkspaces *RegionsAllowedWorkspaceBoolExp `json:"regions_allowed_workspaces,omitempty"`
	Slug                     *StringComparisonExp            `json:"slug,omitempty"`
	TaxIDType                *StringComparisonExp            `json:"taxIdType,omitempty"`
	TaxIDValue               *StringComparisonExp            `json:"taxIdValue,omitempty"`
	UpdatedAt                *TimestamptzComparisonExp       `json:"updatedAt,omitempty"`
	WorkspaceMemberInvites   *WorkspaceMemberInvitesBoolExp  `json:"workspaceMemberInvites,omitempty"`
	WorkspaceMembers         *WorkspaceMembersBoolExp        `json:"workspaceMembers,omitempty"`
}

Boolean expression to filter rows from the table "workspaces". All fields are combined with a logical 'AND'.

type WorkspacesConstraint 

type WorkspacesConstraint string

unique or primary key constraints on table "workspaces" 

const (
	// unique or primary key constraint on columns "id"
	WorkspacesConstraintWorkspacesPkey WorkspacesConstraint = "workspaces_pkey"
	// unique or primary key constraint on columns "slug"
	WorkspacesConstraintWorkspacesSlugKey WorkspacesConstraint = "workspaces_slug_key"
)

func (WorkspacesConstraint) IsValid 

func (e WorkspacesConstraint) IsValid() bool

func (WorkspacesConstraint) MarshalGQL 

func (e WorkspacesConstraint) MarshalGQL(w io.Writer)

func (WorkspacesConstraint) String 

func (e WorkspacesConstraint) String() string

func (*WorkspacesConstraint) UnmarshalGQL 

func (e *WorkspacesConstraint) UnmarshalGQL(v interface{}) error

type WorkspacesInsertInput 

type WorkspacesInsertInput struct {
	Apps                   *AppsArrRelInsertInput                   `json:"apps,omitempty"`
	CompanyName            *string                                  `json:"companyName,omitempty"`
	Email                  *string                                  `json:"email,omitempty"`
	ID                     *string                                  `json:"id,omitempty"`
	Name                   *string                                  `json:"name,omitempty"`
	PaymentMethod          *PaymentMethodsObjRelInsertInput         `json:"paymentMethod,omitempty"`
	PaymentMethods         *PaymentMethodsArrRelInsertInput         `json:"paymentMethods,omitempty"`
	Slug                   *string                                  `json:"slug,omitempty"`
	WorkspaceMemberInvites *WorkspaceMemberInvitesArrRelInsertInput `json:"workspaceMemberInvites,omitempty"`
	WorkspaceMembers       *WorkspaceMembersArrRelInsertInput       `json:"workspaceMembers,omitempty"`
}

input type for inserting data into table "workspaces"

type WorkspacesMaxOrderBy 

type WorkspacesMaxOrderBy struct {
	// City, district, suburb, town, or village.
	AddressCity *OrderBy `json:"addressCity,omitempty"`
	// Two-letter country code (ISO 3166-1 alpha-2).
	AddressCountryCode *OrderBy `json:"addressCountryCode,omitempty"`
	// Address line 1 (e.g., street, PO Box, or company name).
	AddressLine1 *OrderBy `json:"addressLine1,omitempty"`
	// Address line 2 (e.g., apartment, suite, unit, or building).
	AddressLine2 *OrderBy `json:"addressLine2,omitempty"`
	// ZIP or postal code.
	AddressPostalCode *OrderBy `json:"addressPostalCode,omitempty"`
	// State, county, province, or region.
	AddressState  *OrderBy `json:"addressState,omitempty"`
	CompanyName   *OrderBy `json:"companyName,omitempty"`
	CreatedAt     *OrderBy `json:"createdAt,omitempty"`
	CreatorUserID *OrderBy `json:"creatorUserId,omitempty"`
	Email         *OrderBy `json:"email,omitempty"`
	ID            *OrderBy `json:"id,omitempty"`
	Name          *OrderBy `json:"name,omitempty"`
	Slug          *OrderBy `json:"slug,omitempty"`
	TaxIDType     *OrderBy `json:"taxIdType,omitempty"`
	TaxIDValue    *OrderBy `json:"taxIdValue,omitempty"`
	UpdatedAt     *OrderBy `json:"updatedAt,omitempty"`
}

order by max() on columns of table "workspaces"

type WorkspacesMinOrderBy 

type WorkspacesMinOrderBy struct {
	// City, district, suburb, town, or village.
	AddressCity *OrderBy `json:"addressCity,omitempty"`
	// Two-letter country code (ISO 3166-1 alpha-2).
	AddressCountryCode *OrderBy `json:"addressCountryCode,omitempty"`
	// Address line 1 (e.g., street, PO Box, or company name).
	AddressLine1 *OrderBy `json:"addressLine1,omitempty"`
	// Address line 2 (e.g., apartment, suite, unit, or building).
	AddressLine2 *OrderBy `json:"addressLine2,omitempty"`
	// ZIP or postal code.
	AddressPostalCode *OrderBy `json:"addressPostalCode,omitempty"`
	// State, county, province, or region.
	AddressState  *OrderBy `json:"addressState,omitempty"`
	CompanyName   *OrderBy `json:"companyName,omitempty"`
	CreatedAt     *OrderBy `json:"createdAt,omitempty"`
	CreatorUserID *OrderBy `json:"creatorUserId,omitempty"`
	Email         *OrderBy `json:"email,omitempty"`
	ID            *OrderBy `json:"id,omitempty"`
	Name          *OrderBy `json:"name,omitempty"`
	Slug          *OrderBy `json:"slug,omitempty"`
	TaxIDType     *OrderBy `json:"taxIdType,omitempty"`
	TaxIDValue    *OrderBy `json:"taxIdValue,omitempty"`
	UpdatedAt     *OrderBy `json:"updatedAt,omitempty"`
}

order by min() on columns of table "workspaces"

type WorkspacesMutationResponse 

type WorkspacesMutationResponse struct {
	// number of rows affected by the mutation
	AffectedRows int64 `json:"affected_rows"`
	// data from the rows affected by the mutation
	Returning []*Workspaces `json:"returning"`
}

response of any mutation on the table "workspaces"

type WorkspacesObjRelInsertInput 

type WorkspacesObjRelInsertInput struct {
	Data *WorkspacesInsertInput `json:"data"`
	// upsert condition
	OnConflict *WorkspacesOnConflict `json:"on_conflict,omitempty"`
}

input type for inserting object relation for remote table "workspaces"

type WorkspacesOnConflict 

type WorkspacesOnConflict struct {
	Constraint    WorkspacesConstraint     `json:"constraint"`
	UpdateColumns []WorkspacesUpdateColumn `json:"update_columns"`
	Where         *WorkspacesBoolExp       `json:"where,omitempty"`
}

on_conflict condition type for table "workspaces"

type WorkspacesOrderBy 

type WorkspacesOrderBy struct {
	AddressCity                       *OrderBy                                 `json:"addressCity,omitempty"`
	AddressCountry                    *CountriesOrderBy                        `json:"addressCountry,omitempty"`
	AddressCountryCode                *OrderBy                                 `json:"addressCountryCode,omitempty"`
	AddressLine1                      *OrderBy                                 `json:"addressLine1,omitempty"`
	AddressLine2                      *OrderBy                                 `json:"addressLine2,omitempty"`
	AddressPostalCode                 *OrderBy                                 `json:"addressPostalCode,omitempty"`
	AddressState                      *OrderBy                                 `json:"addressState,omitempty"`
	AllowedPrivateRegions             *RegionsAllowedWorkspaceOrderBy          `json:"allowedPrivateRegions,omitempty"`
	AppsAggregate                     *AppsAggregateOrderBy                    `json:"apps_aggregate,omitempty"`
	CompanyName                       *OrderBy                                 `json:"companyName,omitempty"`
	CreatedAt                         *OrderBy                                 `json:"createdAt,omitempty"`
	CreatorUser                       *UsersOrderBy                            `json:"creatorUser,omitempty"`
	CreatorUserID                     *OrderBy                                 `json:"creatorUserId,omitempty"`
	Email                             *OrderBy                                 `json:"email,omitempty"`
	ID                                *OrderBy                                 `json:"id,omitempty"`
	Name                              *OrderBy                                 `json:"name,omitempty"`
	PaymentMethod                     *PaymentMethodsOrderBy                   `json:"paymentMethod,omitempty"`
	PaymentMethodsAggregate           *PaymentMethodsAggregateOrderBy          `json:"paymentMethods_aggregate,omitempty"`
	RegionsAllowedWorkspacesAggregate *RegionsAllowedWorkspaceAggregateOrderBy `json:"regions_allowed_workspaces_aggregate,omitempty"`
	Slug                              *OrderBy                                 `json:"slug,omitempty"`
	TaxIDType                         *OrderBy                                 `json:"taxIdType,omitempty"`
	TaxIDValue                        *OrderBy                                 `json:"taxIdValue,omitempty"`
	UpdatedAt                         *OrderBy                                 `json:"updatedAt,omitempty"`
	WorkspaceMemberInvitesAggregate   *WorkspaceMemberInvitesAggregateOrderBy  `json:"workspaceMemberInvites_aggregate,omitempty"`
	WorkspaceMembersAggregate         *WorkspaceMembersAggregateOrderBy        `json:"workspaceMembers_aggregate,omitempty"`
}

Ordering options when selecting data from "workspaces".

type WorkspacesPkColumnsInput 

type WorkspacesPkColumnsInput struct {
	ID string `json:"id"`
}

primary key columns input for table: workspaces

type WorkspacesSelectColumn 

type WorkspacesSelectColumn string

select columns of table "workspaces" 

const (
	// column name
	WorkspacesSelectColumnAddressCity WorkspacesSelectColumn = "addressCity"
	// column name
	WorkspacesSelectColumnAddressCountryCode WorkspacesSelectColumn = "addressCountryCode"
	// column name
	WorkspacesSelectColumnAddressLine1 WorkspacesSelectColumn = "addressLine1"
	// column name
	WorkspacesSelectColumnAddressLine2 WorkspacesSelectColumn = "addressLine2"
	// column name
	WorkspacesSelectColumnAddressPostalCode WorkspacesSelectColumn = "addressPostalCode"
	// column name
	WorkspacesSelectColumnAddressState WorkspacesSelectColumn = "addressState"
	// column name
	WorkspacesSelectColumnCompanyName WorkspacesSelectColumn = "companyName"
	// column name
	WorkspacesSelectColumnCreatedAt WorkspacesSelectColumn = "createdAt"
	// column name
	WorkspacesSelectColumnCreatorUserID WorkspacesSelectColumn = "creatorUserId"
	// column name
	WorkspacesSelectColumnEmail WorkspacesSelectColumn = "email"
	// column name
	WorkspacesSelectColumnID WorkspacesSelectColumn = "id"
	// column name
	WorkspacesSelectColumnName WorkspacesSelectColumn = "name"
	// column name
	WorkspacesSelectColumnSlug WorkspacesSelectColumn = "slug"
	// column name
	WorkspacesSelectColumnTaxIDType WorkspacesSelectColumn = "taxIdType"
	// column name
	WorkspacesSelectColumnTaxIDValue WorkspacesSelectColumn = "taxIdValue"
	// column name
	WorkspacesSelectColumnUpdatedAt WorkspacesSelectColumn = "updatedAt"
)

func (WorkspacesSelectColumn) IsValid 

func (e WorkspacesSelectColumn) IsValid() bool

func (WorkspacesSelectColumn) MarshalGQL 

func (e WorkspacesSelectColumn) MarshalGQL(w io.Writer)

func (WorkspacesSelectColumn) String 

func (e WorkspacesSelectColumn) String() string

func (*WorkspacesSelectColumn) UnmarshalGQL 

func (e *WorkspacesSelectColumn) UnmarshalGQL(v interface{}) error

type WorkspacesSetInput 

type WorkspacesSetInput struct {
	// City, district, suburb, town, or village.
	AddressCity *string `json:"addressCity,omitempty"`
	// Two-letter country code (ISO 3166-1 alpha-2).
	AddressCountryCode *string `json:"addressCountryCode,omitempty"`
	// Address line 1 (e.g., street, PO Box, or company name).
	AddressLine1 *string `json:"addressLine1,omitempty"`
	// Address line 2 (e.g., apartment, suite, unit, or building).
	AddressLine2 *string `json:"addressLine2,omitempty"`
	// ZIP or postal code.
	AddressPostalCode *string `json:"addressPostalCode,omitempty"`
	// State, county, province, or region.
	AddressState *string `json:"addressState,omitempty"`
	CompanyName  *string `json:"companyName,omitempty"`
	Email        *string `json:"email,omitempty"`
	Name         *string `json:"name,omitempty"`
	Slug         *string `json:"slug,omitempty"`
	TaxIDType    *string `json:"taxIdType,omitempty"`
	TaxIDValue   *string `json:"taxIdValue,omitempty"`
}

input type for updating data in table "workspaces"

type WorkspacesStreamCursorInput 

type WorkspacesStreamCursorInput struct {
	// Stream column input with initial value
	InitialValue *WorkspacesStreamCursorValueInput `json:"initial_value"`
	// cursor ordering
	Ordering *CursorOrdering `json:"ordering,omitempty"`
}

Streaming cursor of the table "workspaces"

type WorkspacesStreamCursorValueInput 

type WorkspacesStreamCursorValueInput struct {
	// City, district, suburb, town, or village.
	AddressCity *string `json:"addressCity,omitempty"`
	// Two-letter country code (ISO 3166-1 alpha-2).
	AddressCountryCode *string `json:"addressCountryCode,omitempty"`
	// Address line 1 (e.g., street, PO Box, or company name).
	AddressLine1 *string `json:"addressLine1,omitempty"`
	// Address line 2 (e.g., apartment, suite, unit, or building).
	AddressLine2 *string `json:"addressLine2,omitempty"`
	// ZIP or postal code.
	AddressPostalCode *string `json:"addressPostalCode,omitempty"`
	// State, county, province, or region.
	AddressState  *string    `json:"addressState,omitempty"`
	CompanyName   *string    `json:"companyName,omitempty"`
	CreatedAt     *time.Time `json:"createdAt,omitempty"`
	CreatorUserID *string    `json:"creatorUserId,omitempty"`
	Email         *string    `json:"email,omitempty"`
	ID            *string    `json:"id,omitempty"`
	Name          *string    `json:"name,omitempty"`
	Slug          *string    `json:"slug,omitempty"`
	TaxIDType     *string    `json:"taxIdType,omitempty"`
	TaxIDValue    *string    `json:"taxIdValue,omitempty"`
	UpdatedAt     *time.Time `json:"updatedAt,omitempty"`
}

Initial value of the column from where the streaming should start

type WorkspacesUpdateColumn 

type WorkspacesUpdateColumn string

update columns of table "workspaces" 

const (
	// column name
	WorkspacesUpdateColumnAddressCity WorkspacesUpdateColumn = "addressCity"
	// column name
	WorkspacesUpdateColumnAddressCountryCode WorkspacesUpdateColumn = "addressCountryCode"
	// column name
	WorkspacesUpdateColumnAddressLine1 WorkspacesUpdateColumn = "addressLine1"
	// column name
	WorkspacesUpdateColumnAddressLine2 WorkspacesUpdateColumn = "addressLine2"
	// column name
	WorkspacesUpdateColumnAddressPostalCode WorkspacesUpdateColumn = "addressPostalCode"
	// column name
	WorkspacesUpdateColumnAddressState WorkspacesUpdateColumn = "addressState"
	// column name
	WorkspacesUpdateColumnCompanyName WorkspacesUpdateColumn = "companyName"
	// column name
	WorkspacesUpdateColumnEmail WorkspacesUpdateColumn = "email"
	// column name
	WorkspacesUpdateColumnName WorkspacesUpdateColumn = "name"
	// column name
	WorkspacesUpdateColumnSlug WorkspacesUpdateColumn = "slug"
	// column name
	WorkspacesUpdateColumnTaxIDType WorkspacesUpdateColumn = "taxIdType"
	// column name
	WorkspacesUpdateColumnTaxIDValue WorkspacesUpdateColumn = "taxIdValue"
)

func (WorkspacesUpdateColumn) IsValid 

func (e WorkspacesUpdateColumn) IsValid() bool

func (WorkspacesUpdateColumn) MarshalGQL 

func (e WorkspacesUpdateColumn) MarshalGQL(w io.Writer)

func (WorkspacesUpdateColumn) String 

func (e WorkspacesUpdateColumn) String() string

func (*WorkspacesUpdateColumn) UnmarshalGQL 

func (e *WorkspacesUpdateColumn) UnmarshalGQL(v interface{}) error

type WorkspacesUpdates 

type WorkspacesUpdates struct {
	// sets the columns of the filtered rows to the given values
	Set *WorkspacesSetInput `json:"_set,omitempty"`
	// filter the rows which have to be updated
	Where *WorkspacesBoolExp `json:"where"`
}

Source Files

View all Source files

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.