sdk

type AgileBoard = work.Board

type AgileBoardColumns = work.BoardColumns

type AgileBoardType = work.BoardType

type AgileBoardUpdate struct {
	Set struct {
		Active *bool
		Name   *string
	}
	Unset struct {
	}
	Push struct {
	}
	Pull struct {
	}
}

type AgileKanban = work.Kanban

type AgileKanbanColumns = work.KanbanColumns

type AgileSprint = work.Sprint

type AgileSprintClosedDate = work.SprintCompletedDate

type AgileSprintColumns = work.SprintColumns

type AgileSprintCreateMutation struct {
	Name         string            `json:"name"`             // Name is the name of the sprint
	Goal         *string           `json:"goal,omitempty"`   // Goal is the optional goal for the sprint
	Status       AgileSprintStatus `json:"status,omitempty"` // Status is the status of the sprint
	StartDate    time.Time         `json:"start_date"`       // StartDate is the start date for the sprint
	EndDate      time.Time         `json:"end_date"`         // EndDate is the end date for the sprint
	IssueRefIDs  []string          `json:"issue_ref_ids"`    // IssueRefIDs is an array of issue ref_ids to add to the sprint
	ProjectRefID string            `json:"project_id"`       // ProjectID is the id to the issue project as a ref_id
}

type AgileSprintEndDate = work.SprintEndedDate

type AgileSprintStartDate = work.SprintStartedDate

type AgileSprintStatus = work.SprintStatus

type AgileSprintUpdate struct {
	Set struct {
		Active        *bool
		Name          *string
		Goal          *string
		StartedDate   *time.Time
		CompletedDate *time.Time
		EndedDate     *time.Time
		Status        *work.SprintStatus
	}
	Unset struct {
		Goal *string
	}
	Push struct {
	}
	Pull struct {
	}
}

type AgileSprintUpdateMutation struct {
	Set struct {
		Name        *string            `json:"name,omitempty"`          // Name is the name of the sprint to update
		Goal        *string            `json:"goal,omitempty"`          // Goal is the optional goal for the sprint
		Status      *AgileSprintStatus `json:"status,omitempty"`        // Status is the status of the sprint
		StartDate   *time.Time         `json:"start_date,omitempty"`    // StartDate is the start date for the sprint
		EndDate     *time.Time         `json:"end_date,omitempty"`      // EndDate is the end date for the sprint
		IssueRefIDs []string           `json:"issue_ref_ids,omitempty"` // IssueRefIDs is an array of issue ref_ids to add to the sprint
	} `json:"set"`
	Unset struct {
		IssueRefIDs []string `json:"issue_ref_ids,omitempty"` // IssueRefIDs is an array of issue ref_ids to remove from the sprint
	} `json:"unset"`
}

type Async interface {
	Do(f func() error)
	Wait() error
}

type AuthManager interface {
	// RefreshOAuth2Token will refresh the OAuth2 access token using the provided refreshToken and return a new access token
	RefreshOAuth2Token(refType string, refreshToken string) (string, error)
	// PrivateKey will return a private key stored by the integration UI
	PrivateKey(identifier Identifier) (*rsa.PrivateKey, error)
}

type AuthorizationType string

type CalendarCalendar = calendar.Calendar

type CalendarEvent = calendar.Event

type CalendarEventEndDate = calendar.EventEndDate

type CalendarEventLocation = calendar.EventLocation

type CalendarEventParticipants = calendar.EventParticipants

type CalendarEventParticipantsStatus = calendar.EventParticipantsStatus

type CalendarEventStartDate = calendar.EventStartDate

type CalendarEventStatus = calendar.EventStatus

type CalendarUser = calendar.User

type Config struct {
	IntegrationType IntegrationType `json:"integrationType"`
	OAuth1Auth      *oauth1Auth     `json:"oauth1_auth,omitempty"`
	OAuth2Auth      *oauth2Auth     `json:"oauth2_auth,omitempty"`
	BasicAuth       *basicAuth      `json:"basic_auth,omitempty"`
	APIKeyAuth      *apikeyAuth     `json:"apikey_auth,omitempty"`
	Inclusions      *matchList      `json:"-"`
	Exclusions      *matchList      `json:"-"`
	Accounts        *ConfigAccounts `json:"-"`
	// contains filtered or unexported fields
}

type ConfigAccount struct {
	ID     string            `json:"id"`
	Type   ConfigAccountType `json:"type"`
	Public bool              `json:"public"`
}

type ConfigAccountType string

type ConfigAccounts map[string]*ConfigAccount

type Control interface {
	Identifier
	// Paused must be called when the integration is paused for any reason such as rate limiting
	Paused(resetAt time.Time) error
	// Resumed must be called when a paused integration is resumed
	Resumed() error
}

type Date = datetime.Date

type Descriptor struct {
	Name           string       `json:"name" yaml:"name"`
	RefType        string       `json:"ref_type" yaml:"ref_type"`
	Description    string       `json:"description" yaml:"description"`
	AvatarURL      string       `json:"avatar_url" yaml:"avatar_url"`
	Capabilities   []string     `json:"capabilities" yaml:"capabilities"`
	Installation   Installation `json:"installation" yaml:"installation"`
	BuildDate      time.Time    `json:"-" yaml:"-"`
	BuildCommitSHA string       `json:"-" yaml:"-"`
}

type Export interface {
	Control
	// Config is any customer specific configuration for this customer
	Config() Config
	// State is a customer specific state object for this integration and customer
	State() State
	// Stats is the stats object that an integration can use to track integration specific stats for the export
	Stats() map[string]interface{}
	// JobID will return a specific job id for this export which can be used in logs, etc
	JobID() string
	// Pipe should be called to get the pipe for streaming data back to pinpoint
	Pipe() Pipe
	// Historical if true, the integration should perform a full historical export
	Historical() bool
}

type GraphQLClient interface {
	Query(query string, variables map[string]interface{}, out interface{}, options ...WithGraphQLOption) error
}

type GraphQLClientManager interface {
	// New is for creating a new graphql client instance that can be reused
	New(url string, headers map[string]string) GraphQLClient
}

type HTTPClient interface {
	// Get will call a HTTP GET method and set the result (if JSON) to out
	Get(out interface{}, options ...WithHTTPOption) (*HTTPResponse, error)
	// Post will call a HTTP POST method passing the data and set the result (if JSON) to out
	Post(data io.Reader, out interface{}, options ...WithHTTPOption) (*HTTPResponse, error)
	// Put will call a HTTP PUT method passing the data and set the result (if JSON) to out
	Put(data io.Reader, out interface{}, options ...WithHTTPOption) (*HTTPResponse, error)
	// Patch will call a HTTP PATCH method passing the data and set the result (if JSON) to out
	Patch(data io.Reader, out interface{}, options ...WithHTTPOption) (*HTTPResponse, error)
	// Delete will call a HTTP DELETE method and set the result (if JSON) to out
	Delete(out interface{}, options ...WithHTTPOption) (*HTTPResponse, error)
}

type HTTPClientManager interface {
	// New is for creating a new HTTP client instance that can be reused
	New(url string, headers map[string]string) HTTPClient
}

type HTTPError struct {
	StatusCode int
	Body       io.Reader
}

type HTTPOptions struct {
	Request     *http.Request
	Response    *HTTPResponse // only set in the response case or nil in the request case
	Deadline    time.Time
	ShouldRetry bool
	RetryAfter  time.Duration
	Transport   http.RoundTripper
}

type HTTPResponse struct {
	StatusCode int
	Headers    http.Header
	Body       []byte
}

type Identifier interface {
	// CustomerID will return the customer id for this instance
	CustomerID() string
	// IntegrationInstanceID will return the unique instance id for this integration for a customer
	IntegrationInstanceID() string
	// RefType for the integration
	RefType() string
}

type Installation struct {
	Modes       []InstallationMode  `json:"modes" yaml:"modes"`
	Cloud       *InstallationConfig `json:"cloud,omitempty" yaml:"cloud"`
	SelfManaged *InstallationConfig `json:"selfmanaged,omitempty" yaml:"selfmanaged"`
}

type InstallationConfig struct {
	Capabilities  []string            `json:"capabilities,omitempty" yaml:"capabilities"`
	Authorization []AuthorizationType `json:"authorizations" yaml:"authorizations"`
}

type InstallationMode string

type Instance struct {
	// contains filtered or unexported fields
}

type Integration interface {
	// Start is called when the integration is starting up
	Start(logger Logger, config Config, manager Manager) error
	// Validate is called before a new integration instance is added to determine
	// if the config is valid and the integration can properly communicate with the
	// source system. The result and the error will both be delivered to the App.
	// Returning a nil error is considered a successful validation.
	Validate(validate Validate) (result map[string]interface{}, err error)
	// Enroll is called when a new integration instance is added
	Enroll(instance Instance) error
	// Dismiss is called when an existing integration instance is removed
	Dismiss(instance Instance) error
	// Export is called to tell the integration to run an export
	Export(export Export) error
	// WebHook is called when a webhook is received on behalf of the integration
	WebHook(webhook WebHook) error
	// Mutation is called when a mutation request is received on behalf of the integration
	Mutation(mutation Mutation) error
	// Stop is called when the integration is shutting down for cleanup
	Stop() error
}

type IntegrationType string

type Logger = log.Logger

type Manager interface {
	// GraphQLManager returns a graphql manager instance
	GraphQLManager() GraphQLClientManager
	// HTTPManager returns a HTTP manager instance
	HTTPManager() HTTPClientManager
	// WebHookManager returns the WebHook manager instance
	WebHookManager() WebHookManager
	// AuthManager returns the Auth manager instance
	AuthManager() AuthManager
	// UserManager returns the User manager instance
	UserManager() UserManager
	// Close is called on shutdown to cleanup any resources
	Close() error
}

type Model = datamodel.Model

type Mutation interface {
	Control
	// Config is any customer specific configuration for this customer
	Config() Config
	// State is a customer specific state object for this integration and customer
	State() State
	// Pipe should be called to get the pipe for streaming data back to pinpoint
	Pipe() Pipe
	// ID is the primary key of the payload
	ID() string
	// Model is the name of the model of the payload
	Model() string
	// Action is the mutation action
	Action() MutationAction
	// Payload is the payload of the mutation which is one of the mutation types
	Payload() interface{}
	// User is the user that is requesting the mutation and any authorization details that might be required
	User() MutationUser
}

type MutationAction string

type MutationUser struct {
	// ID is the ref_id to the source system
	ID         string      `json:"id"`
	OAuth2Auth *oauth2Auth `json:"oauth2_auth,omitempty"`
	BasicAuth  *basicAuth  `json:"basic_auth,omitempty"`
	APIKeyAuth *apikeyAuth `json:"apikey_auth,omitempty"`
}

type NameID struct {
	ID   *string `json:"id,omitempty"`
	Name *string `json:"name,omitempty"`
}

type NameRefID struct {
	RefID *string `json:"ref_id,omitempty"`
	Name  *string `json:"name,omitempty"`
}

type PartialModel = datamodel.PartialModel

type Pipe interface {
	// Write a model back to the output system
	Write(object Model) error
	// Flush will tell the pipe to flush any pending data
	Flush() error
	// Close is called when the integration has completed and no more data will be sent
	Close() error
}

type RateLimitError struct {
	RetryAfter time.Duration
}

type SourceCodeCommit = sourcecode.Commit

type SourceCodeCommitCreatedDate = sourcecode.CommitCreatedDate

type SourceCodePullRequest = sourcecode.PullRequest

type SourceCodePullRequestClosedDate = sourcecode.PullRequestClosedDate

type SourceCodePullRequestComment = sourcecode.PullRequestComment

type SourceCodePullRequestCommentCreatedDate = sourcecode.PullRequestCommentCreatedDate

type SourceCodePullRequestCommentUpdatedDate = sourcecode.PullRequestCommentUpdatedDate

type SourceCodePullRequestCommit = sourcecode.PullRequestCommit

type SourceCodePullRequestCommitCreatedDate = sourcecode.PullRequestCommitCreatedDate

type SourceCodePullRequestCreatedDate = sourcecode.PullRequestCreatedDate

type SourceCodePullRequestMergedDate = sourcecode.PullRequestMergedDate

type SourceCodePullRequestReview = sourcecode.PullRequestReview

type SourceCodePullRequestReviewCreatedDate = sourcecode.PullRequestReviewCreatedDate

type SourceCodePullRequestReviewState = sourcecode.PullRequestReviewState

type SourceCodePullRequestStatus = sourcecode.PullRequestStatus

type SourceCodePullRequestUpdatedDate = sourcecode.PullRequestUpdatedDate

type SourceCodeRepo = sourcecode.Repo

type SourceCodeRepoAffiliation = sourcecode.RepoAffiliation

type SourceCodeRepoVisibility = sourcecode.RepoVisibility

type SourceCodeUser = sourcecode.User

type SourceCodeUserType = sourcecode.UserType

type SourcecodePullRequestUpdateMutation struct {
	Set struct {
		Title       *string                      `json:"title,omitempty"`       // Title is for updating the title to the pull request
		Description *string                      `json:"description,omitempty"` // Description is for updating the description of the pull request
		Status      *SourceCodePullRequestStatus `json:"status,omitempty"`      // Status is for changing the status of the pull request
	} `json:"set"`
}

type State interface {
	// Set a value by key in state. the value must be able to serialize to JSON
	Set(key string, value interface{}) error
	// SetWithExpires will set key and value and it will automatically expire from state after expiry
	SetWithExpires(key string, value interface{}, expiry time.Duration) error
	// Get will return a value for a given key and set the value to the address of out
	Get(key string, out interface{}) (bool, error)
	// Exists return true if the key exists in state
	Exists(key string) bool
	// Delete will return data for key in state
	Delete(key string) error
	// Flush any pending data to storage
	Flush() error
}

type User struct {
	ID                  string   `json:"_id"`
	Name                string   `json:"name"`
	Emails              []string `json:"emails"`
	RefID               string   `json:"ref_id"`
	OAuth1Authorization *struct {
		Date        int64  `json:"date_ts"`
		ConsumerKey string `json:"consumer_key"`
		Token       string `json:"token"`
		TokenSecret string `json:"token_secret"`
	} `json:"oauth1_authorization"`
	OAuth2Authorization *struct {
		Date         int64   `json:"date_ts"`
		AccessToken  string  `json:"token"`
		RefreshToken *string `json:"refresh_token"`
		Scopes       string  `json:"scopes"`
	} `json:"oauth_authorization"`
}

type UserManager interface {
	// Users will return the integration users for a given integration instance
	Users(control Control) ([]User, error)
}

type Validate interface {
	Identifier
	Config() Config
}

type ValidatedAccount struct {
	ID          string `json:"id"`
	Name        string `json:"name"`
	Description string `json:"description"`
	AvatarURL   string `json:"avatarUrl"`
	TotalCount  int    `json:"totalCount"`
	Type        string `json:"type"`
	Public      bool   `json:"public"`
}

type WebHook interface {
	Control
	// Config is any customer specific configuration for this customer
	Config() Config
	// State is a customer specific state object for this integration and customer
	State() State
	// RefID will return the ref id from when the hook was created
	RefID() string
	// Pipe returns a pipe for sending data back to pinpoint from the web hook data
	Pipe() Pipe
	// Data returns the payload of a webhook decoded from json into a map
	Data() (map[string]interface{}, error)
	// Bytes will return the underlying data as bytes
	Bytes() []byte
	// URL the webhook callback url
	URL() string
	// Headers are the headers that came from the web hook
	Headers() map[string]string
	// Scope is the registered webhook scope
	Scope() WebHookScope
}

type WebHookManager interface {
	// Create is used by the integration to create a webhook on behalf of the integration for a given customer, reftype and refid
	// the result will be a fully qualified URL to the webhook endpoint that should be registered with the integration
	Create(customerID string, integrationInstanceID string, refType string, refID string, scope WebHookScope, params ...string) (string, error)
	// Delete will remove the webhook from the entity based on scope
	Delete(customerID string, integrationInstanceID string, refType string, refID string, scope WebHookScope) error
	// Exists returns true if the webhook is registered for the given entity based on ref_id and scope
	Exists(customerID string, integrationInstanceID string, refType string, refID string, scope WebHookScope) bool
	// Errored will set the errored state on the webhook and the message will be the Error() value of the error
	Errored(customerID string, integrationInstanceID string, refType string, refID string, scope WebHookScope, err error)
	// HookURL will return the webhook url
	HookURL(customerID string, integrationInstanceID string, refType string, refID string, scope WebHookScope) (string, error)
}

type WebHookScope string

type WithGraphQLOption func(req *http.Request) error

type WithHTTPOption func(opt *HTTPOptions) error

type WorkConfig = work.Config

type WorkConfigStatuses = work.ConfigStatuses

type WorkIssue = work.Issue

type WorkIssueAttachments = work.IssueAttachments

type WorkIssueChangeLog = work.IssueChangeLog

type WorkIssueChangeLogCreatedDate = work.IssueChangeLogCreatedDate

type WorkIssueChangeLogField = work.IssueChangeLogField

type WorkIssueComment = work.IssueComment

type WorkIssueCommentCreatedDate = work.IssueCommentCreatedDate

type WorkIssueCommentUpdate struct {
	Set struct {
		Active *bool
	}
	Unset struct {
	}
	Push struct {
	}
	Pull struct {
	}
}

type WorkIssueCommentUpdatedDate = work.IssueCommentUpdatedDate

type WorkIssueCreateMutation struct {
	Title         string   `json:"title"`               // Title is for setting the title of the issue
	Description   string   `json:"description"`         // Description is for setting the description of the issue
	AssigneeRefID *string  `json:"assignee,omitempty"`  // AssigneeRefID is for setting the assignee of the issue to a ref_id
	Priority      *NameID  `json:"priority,omitempty"`  // Priority is for setting the priority of the issue
	Type          *NameID  `json:"type,omitempty"`      // Type is for setting the issue type of the issue
	ProjectRefID  string   `json:"project_id"`          // ProjectID is the id to the issue project as a ref_id
	Epic          *NameID  `json:"epic,omitempty"`      // Epic is for setting an epic for the issue
	ParentRefID   *string  `json:"parent_id,omitempty"` // ParentRefID is for setting the parent issue as a ref_id
	Labels        []string `json:"labels,omitempty"`    // Labels is for setting the labels for an issue
}

type WorkIssueCreatedDate = work.IssueCreatedDate

type WorkIssueDueDate = work.IssueDueDate

type WorkIssueLinkedIssues = work.IssueLinkedIssues

type WorkIssueLinkedIssuesLinkType = work.IssueLinkedIssuesLinkType

type WorkIssuePlannedEndDate = work.IssuePlannedEndDate

type WorkIssuePlannedStartDate = work.IssuePlannedStartDate

type WorkIssuePriority = work.IssuePriority

type WorkIssueStatus = work.IssueStatus

type WorkIssueTransitions = work.IssueTransitions

type WorkIssueType = work.IssueType

type WorkIssueTypeMappedType = work.IssueTypeMappedType

type WorkIssueUpdate struct {
	Set struct {
		Title            *string
		Description      *string
		Active           *bool
		StoryPoints      *float32
		Identifier       *string
		ProjectID        *string
		URL              *string
		DueDate          *time.Time
		Priority         *NameID
		Type             *NameID
		Status           *NameID
		AssigneeRefID    *string
		ParentID         *string
		Tags             *[]string
		EpicID           *string
		Resolution       *string
		PlannedStartDate *time.Time
		PlannedEndDate   *time.Time
		SprintIDs        *[]string
		Transitions      *[]NameRefID
	}
	Unset struct {
		StoryPoints      *bool
		DueDate          *bool
		ParentID         *bool
		EpicID           *bool
		PlannedStartDate *bool
		PlannedEndDate   *bool
	}
	Push struct {
		Tags         *[]string
		SprintIDs    *[]string
		ChangeLogs   *[]WorkIssueChangeLog
		LinkedIssues *[]WorkIssueLinkedIssues
	}
	Pull struct {
		Tags         *[]string
		SprintIDs    *[]string
		LinkedIssues *[]WorkIssueLinkedIssues
	}
}

type WorkIssueUpdateMutation struct {
	Set struct {
		Title         *string `json:"title"`                // Title is for updating the title to the issue
		Transition    *NameID `json:"transition,omitempty"` // Transition information (if used) for the issue
		Status        *NameID `json:"status,omitempty"`     // Status is for changing the status of the issue
		Priority      *NameID `json:"priority,omitempty"`   // Priority is for changing the priority of the issue
		Resolution    *NameID `json:"resolution,omitempty"` // Resolution is for changing the resolution of the issue
		Epic          *NameID `json:"epic,omitempty"`       // Epic is for updating the epic for the issue
		AssigneeRefID *string `json:"assignee,omitempty"`   // AssigneeRefID is for changing the assignee of the issue to a ref_id
	} `json:"set"`
	Unset struct {
		Epic     bool `json:"epic"`     // Epic is for removing the epic from the issue (if set to true)
		Assignee bool `json:"assignee"` // Assignee is for removing the assignee from the issue (if set to true)
	} `json:"unset"`
}

type WorkIssueUpdatedDate = work.IssueUpdatedDate

type WorkProject = work.Project

type WorkProjectAffiliation = work.ProjectAffiliation

type WorkProjectCapability = work.ProjectCapability

type WorkProjectIssueResolutions = work.ProjectIssueResolutions

type WorkProjectIssueTypes = work.ProjectIssueTypes

type WorkProjectUpdate struct {
	Set struct {
		Active      *bool
		Name        *string
		Description *string
	}
	Unset struct {
	}
	Push struct {
	}
	Pull struct {
	}
}

type WorkProjectVisibility = work.ProjectVisibility

type WorkUser = work.User