okta.lr.go

// Copyright Mondoo, Inc. 2024, 2026
// SPDX-License-Identifier: BUSL-1.1

// Code generated by resources. DO NOT EDIT.

package resources

import (
	"errors"
	"time"

	"go.mondoo.com/mql/v13/llx"
	"go.mondoo.com/mql/v13/providers-sdk/v1/plugin"
	"go.mondoo.com/mql/v13/types"
)

// The MQL type names exposed as public consts for ease of reference.
const (
	ResourceOkta                     string = "okta"
	ResourceOktaOrganization         string = "okta.organization"
	ResourceOktaPolicies             string = "okta.policies"
	ResourceOktaUser                 string = "okta.user"
	ResourceOktaRole                 string = "okta.role"
	ResourceOktaGroup                string = "okta.group"
	ResourceOktaGroupRule            string = "okta.groupRule"
	ResourceOktaApplication          string = "okta.application"
	ResourceOktaDomain               string = "okta.domain"
	ResourceOktaPolicy               string = "okta.policy"
	ResourceOktaPolicyRule           string = "okta.policyRule"
	ResourceOktaTrustedOrigin        string = "okta.trustedOrigin"
	ResourceOktaNetwork              string = "okta.network"
	ResourceOktaThreatsConfiguration string = "okta.threatsConfiguration"
	ResourceOktaCustomRole           string = "okta.customRole"
)

var resourceFactories map[string]plugin.ResourceFactory

func init() {
	resourceFactories = map[string]plugin.ResourceFactory{
		"okta": {
			// to override args, implement: initOkta(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error)
			Create: createOkta,
		},
		"okta.organization": {
			Init:   initOktaOrganization,
			Create: createOktaOrganization,
		},
		"okta.policies": {
			// to override args, implement: initOktaPolicies(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error)
			Create: createOktaPolicies,
		},
		"okta.user": {
			// to override args, implement: initOktaUser(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error)
			Create: createOktaUser,
		},
		"okta.role": {
			// to override args, implement: initOktaRole(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error)
			Create: createOktaRole,
		},
		"okta.group": {
			// to override args, implement: initOktaGroup(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error)
			Create: createOktaGroup,
		},
		"okta.groupRule": {
			// to override args, implement: initOktaGroupRule(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error)
			Create: createOktaGroupRule,
		},
		"okta.application": {
			// to override args, implement: initOktaApplication(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error)
			Create: createOktaApplication,
		},
		"okta.domain": {
			// to override args, implement: initOktaDomain(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error)
			Create: createOktaDomain,
		},
		"okta.policy": {
			// to override args, implement: initOktaPolicy(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error)
			Create: createOktaPolicy,
		},
		"okta.policyRule": {
			// to override args, implement: initOktaPolicyRule(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error)
			Create: createOktaPolicyRule,
		},
		"okta.trustedOrigin": {
			// to override args, implement: initOktaTrustedOrigin(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error)
			Create: createOktaTrustedOrigin,
		},
		"okta.network": {
			// to override args, implement: initOktaNetwork(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error)
			Create: createOktaNetwork,
		},
		"okta.threatsConfiguration": {
			// to override args, implement: initOktaThreatsConfiguration(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error)
			Create: createOktaThreatsConfiguration,
		},
		"okta.customRole": {
			// to override args, implement: initOktaCustomRole(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error)
			Create: createOktaCustomRole,
		},
	}
}

// NewResource is used by the runtime of this plugin to create new resources.
// Its arguments may be provided by users. This function is generally not
// used by initializing resources from recordings or from lists.
func NewResource(runtime *plugin.Runtime, name string, args map[string]*llx.RawData) (plugin.Resource, error) {
	f, ok := resourceFactories[name]
	if !ok {
		return nil, errors.New("cannot find resource " + name + " in this provider")
	}

	if f.Init != nil {
		cargs, res, err := f.Init(runtime, args)
		if err != nil {
			return res, err
		}

		if res != nil {
			mqlId := res.MqlID()
			id := name + "\x00" + mqlId
			if x, ok := runtime.Resources.Get(id); ok {
				return x, nil
			}
			runtime.Resources.Set(id, res)
			return res, nil
		}

		args = cargs
	}

	res, err := f.Create(runtime, args)
	if err != nil {
		return nil, err
	}

	mqlId := res.MqlID()
	id := name + "\x00" + mqlId
	if x, ok := runtime.Resources.Get(id); ok {
		return x, nil
	}

	runtime.Resources.Set(id, res)
	return res, nil
}

// CreateResource is used by the runtime of this plugin to create resources.
// Its arguments must be complete and pre-processed. This method is used
// for initializing resources from recordings or from lists.
func CreateResource(runtime *plugin.Runtime, name string, args map[string]*llx.RawData) (plugin.Resource, error) {
	f, ok := resourceFactories[name]
	if !ok {
		return nil, errors.New("cannot find resource " + name + " in this provider")
	}

	res, err := f.Create(runtime, args)
	if err != nil {
		return nil, err
	}

	mqlId := res.MqlID()
	id := name + "\x00" + mqlId
	if x, ok := runtime.Resources.Get(id); ok {
		return x, nil
	}

	runtime.Resources.Set(id, res)
	return res, nil
}

var getDataFields = map[string]func(r plugin.Resource) *plugin.DataRes{
	"okta.users": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOkta).GetUsers()).ToDataRes(types.Array(types.Resource("okta.user")))
	},
	"okta.groups": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOkta).GetGroups()).ToDataRes(types.Array(types.Resource("okta.group")))
	},
	"okta.groupRules": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOkta).GetGroupRules()).ToDataRes(types.Array(types.Resource("okta.groupRule")))
	},
	"okta.domains": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOkta).GetDomains()).ToDataRes(types.Array(types.Resource("okta.domain")))
	},
	"okta.applications": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOkta).GetApplications()).ToDataRes(types.Array(types.Resource("okta.application")))
	},
	"okta.trustedOrigins": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOkta).GetTrustedOrigins()).ToDataRes(types.Array(types.Resource("okta.trustedOrigin")))
	},
	"okta.networks": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOkta).GetNetworks()).ToDataRes(types.Array(types.Resource("okta.network")))
	},
	"okta.customRoles": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOkta).GetCustomRoles()).ToDataRes(types.Array(types.Resource("okta.customRole")))
	},
	"okta.organization.id": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetId()).ToDataRes(types.String)
	},
	"okta.organization.companyName": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetCompanyName()).ToDataRes(types.String)
	},
	"okta.organization.status": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetStatus()).ToDataRes(types.String)
	},
	"okta.organization.subdomain": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetSubdomain()).ToDataRes(types.String)
	},
	"okta.organization.address1": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetAddress1()).ToDataRes(types.String)
	},
	"okta.organization.address2": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetAddress2()).ToDataRes(types.String)
	},
	"okta.organization.city": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetCity()).ToDataRes(types.String)
	},
	"okta.organization.state": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetState()).ToDataRes(types.String)
	},
	"okta.organization.phoneNumber": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetPhoneNumber()).ToDataRes(types.String)
	},
	"okta.organization.postalCode": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetPostalCode()).ToDataRes(types.String)
	},
	"okta.organization.country": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetCountry()).ToDataRes(types.String)
	},
	"okta.organization.supportPhoneNumber": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetSupportPhoneNumber()).ToDataRes(types.String)
	},
	"okta.organization.website": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetWebsite()).ToDataRes(types.String)
	},
	"okta.organization.endUserSupportHelpURL": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetEndUserSupportHelpURL()).ToDataRes(types.String)
	},
	"okta.organization.created": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetCreated()).ToDataRes(types.Time)
	},
	"okta.organization.lastUpdated": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetLastUpdated()).ToDataRes(types.Time)
	},
	"okta.organization.expiresAt": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetExpiresAt()).ToDataRes(types.Time)
	},
	"okta.organization.optOutCommunicationEmails": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetOptOutCommunicationEmails()).ToDataRes(types.Bool)
	},
	"okta.organization.billingContact": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetBillingContact()).ToDataRes(types.Resource("okta.user"))
	},
	"okta.organization.technicalContact": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetTechnicalContact()).ToDataRes(types.Resource("okta.user"))
	},
	"okta.organization.securityNotificationEmails": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetSecurityNotificationEmails()).ToDataRes(types.Dict)
	},
	"okta.organization.threatInsightSettings": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaOrganization).GetThreatInsightSettings()).ToDataRes(types.Resource("okta.threatsConfiguration"))
	},
	"okta.policies.password": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicies).GetPassword()).ToDataRes(types.Array(types.Resource("okta.policy")))
	},
	"okta.policies.mfaEnroll": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicies).GetMfaEnroll()).ToDataRes(types.Array(types.Resource("okta.policy")))
	},
	"okta.policies.signOn": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicies).GetSignOn()).ToDataRes(types.Array(types.Resource("okta.policy")))
	},
	"okta.policies.oauthAuthorizationPolicy": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicies).GetOauthAuthorizationPolicy()).ToDataRes(types.Array(types.Resource("okta.policy")))
	},
	"okta.policies.idpDiscovery": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicies).GetIdpDiscovery()).ToDataRes(types.Array(types.Resource("okta.policy")))
	},
	"okta.policies.accessPolicy": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicies).GetAccessPolicy()).ToDataRes(types.Array(types.Resource("okta.policy")))
	},
	"okta.policies.profileEnrollment": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicies).GetProfileEnrollment()).ToDataRes(types.Array(types.Resource("okta.policy")))
	},
	"okta.user.id": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaUser).GetId()).ToDataRes(types.String)
	},
	"okta.user.typeId": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaUser).GetTypeId()).ToDataRes(types.String)
	},
	"okta.user.type": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaUser).GetType()).ToDataRes(types.Dict)
	},
	"okta.user.credentials": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaUser).GetCredentials()).ToDataRes(types.Dict)
	},
	"okta.user.activated": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaUser).GetActivated()).ToDataRes(types.Time)
	},
	"okta.user.created": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaUser).GetCreated()).ToDataRes(types.Time)
	},
	"okta.user.lastLogin": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaUser).GetLastLogin()).ToDataRes(types.Time)
	},
	"okta.user.lastUpdated": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaUser).GetLastUpdated()).ToDataRes(types.Time)
	},
	"okta.user.passwordChanged": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaUser).GetPasswordChanged()).ToDataRes(types.Time)
	},
	"okta.user.profile": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaUser).GetProfile()).ToDataRes(types.Dict)
	},
	"okta.user.status": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaUser).GetStatus()).ToDataRes(types.String)
	},
	"okta.user.statusChanged": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaUser).GetStatusChanged()).ToDataRes(types.Time)
	},
	"okta.user.transitioningToStatus": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaUser).GetTransitioningToStatus()).ToDataRes(types.String)
	},
	"okta.user.roles": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaUser).GetRoles()).ToDataRes(types.Array(types.Resource("okta.role")))
	},
	"okta.role.id": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaRole).GetId()).ToDataRes(types.String)
	},
	"okta.role.assignmentType": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaRole).GetAssignmentType()).ToDataRes(types.String)
	},
	"okta.role.created": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaRole).GetCreated()).ToDataRes(types.Time)
	},
	"okta.role.label": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaRole).GetLabel()).ToDataRes(types.String)
	},
	"okta.role.lastUpdated": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaRole).GetLastUpdated()).ToDataRes(types.Time)
	},
	"okta.role.status": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaRole).GetStatus()).ToDataRes(types.String)
	},
	"okta.role.type": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaRole).GetType()).ToDataRes(types.String)
	},
	"okta.group.id": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaGroup).GetId()).ToDataRes(types.String)
	},
	"okta.group.name": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaGroup).GetName()).ToDataRes(types.String)
	},
	"okta.group.description": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaGroup).GetDescription()).ToDataRes(types.String)
	},
	"okta.group.type": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaGroup).GetType()).ToDataRes(types.Dict)
	},
	"okta.group.created": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaGroup).GetCreated()).ToDataRes(types.Time)
	},
	"okta.group.lastMembershipUpdated": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaGroup).GetLastMembershipUpdated()).ToDataRes(types.Time)
	},
	"okta.group.lastUpdated": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaGroup).GetLastUpdated()).ToDataRes(types.Time)
	},
	"okta.group.profile": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaGroup).GetProfile()).ToDataRes(types.Dict)
	},
	"okta.group.members": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaGroup).GetMembers()).ToDataRes(types.Array(types.Resource("okta.user")))
	},
	"okta.group.roles": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaGroup).GetRoles()).ToDataRes(types.Array(types.Resource("okta.role")))
	},
	"okta.groupRule.id": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaGroupRule).GetId()).ToDataRes(types.String)
	},
	"okta.groupRule.name": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaGroupRule).GetName()).ToDataRes(types.String)
	},
	"okta.groupRule.status": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaGroupRule).GetStatus()).ToDataRes(types.String)
	},
	"okta.groupRule.type": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaGroupRule).GetType()).ToDataRes(types.String)
	},
	"okta.application.id": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaApplication).GetId()).ToDataRes(types.String)
	},
	"okta.application.name": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaApplication).GetName()).ToDataRes(types.String)
	},
	"okta.application.label": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaApplication).GetLabel()).ToDataRes(types.String)
	},
	"okta.application.created": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaApplication).GetCreated()).ToDataRes(types.Time)
	},
	"okta.application.lastUpdated": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaApplication).GetLastUpdated()).ToDataRes(types.Time)
	},
	"okta.application.credentials": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaApplication).GetCredentials()).ToDataRes(types.Dict)
	},
	"okta.application.features": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaApplication).GetFeatures()).ToDataRes(types.Array(types.String))
	},
	"okta.application.licensing": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaApplication).GetLicensing()).ToDataRes(types.Dict)
	},
	"okta.application.profile": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaApplication).GetProfile()).ToDataRes(types.Dict)
	},
	"okta.application.settings": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaApplication).GetSettings()).ToDataRes(types.Dict)
	},
	"okta.application.signOnMode": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaApplication).GetSignOnMode()).ToDataRes(types.String)
	},
	"okta.application.status": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaApplication).GetStatus()).ToDataRes(types.String)
	},
	"okta.application.visibility": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaApplication).GetVisibility()).ToDataRes(types.Dict)
	},
	"okta.domain.id": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaDomain).GetId()).ToDataRes(types.String)
	},
	"okta.domain.domain": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaDomain).GetDomain()).ToDataRes(types.String)
	},
	"okta.domain.validationStatus": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaDomain).GetValidationStatus()).ToDataRes(types.String)
	},
	"okta.domain.dnsRecords": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaDomain).GetDnsRecords()).ToDataRes(types.Array(types.Dict))
	},
	"okta.domain.publicCertificate": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaDomain).GetPublicCertificate()).ToDataRes(types.Dict)
	},
	"okta.policy.id": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicy).GetId()).ToDataRes(types.String)
	},
	"okta.policy.name": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicy).GetName()).ToDataRes(types.String)
	},
	"okta.policy.description": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicy).GetDescription()).ToDataRes(types.String)
	},
	"okta.policy.priority": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicy).GetPriority()).ToDataRes(types.Int)
	},
	"okta.policy.status": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicy).GetStatus()).ToDataRes(types.String)
	},
	"okta.policy.system": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicy).GetSystem()).ToDataRes(types.Bool)
	},
	"okta.policy.type": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicy).GetType()).ToDataRes(types.String)
	},
	"okta.policy.conditions": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicy).GetConditions()).ToDataRes(types.Dict)
	},
	"okta.policy.settings": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicy).GetSettings()).ToDataRes(types.Dict)
	},
	"okta.policy.created": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicy).GetCreated()).ToDataRes(types.Time)
	},
	"okta.policy.lastUpdated": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicy).GetLastUpdated()).ToDataRes(types.Time)
	},
	"okta.policy.rules": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicy).GetRules()).ToDataRes(types.Array(types.Resource("okta.policyRule")))
	},
	"okta.policyRule.id": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicyRule).GetId()).ToDataRes(types.String)
	},
	"okta.policyRule.name": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicyRule).GetName()).ToDataRes(types.String)
	},
	"okta.policyRule.priority": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicyRule).GetPriority()).ToDataRes(types.Int)
	},
	"okta.policyRule.status": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicyRule).GetStatus()).ToDataRes(types.String)
	},
	"okta.policyRule.system": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicyRule).GetSystem()).ToDataRes(types.Bool)
	},
	"okta.policyRule.type": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicyRule).GetType()).ToDataRes(types.String)
	},
	"okta.policyRule.actions": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicyRule).GetActions()).ToDataRes(types.Dict)
	},
	"okta.policyRule.conditions": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicyRule).GetConditions()).ToDataRes(types.Dict)
	},
	"okta.policyRule.created": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicyRule).GetCreated()).ToDataRes(types.Time)
	},
	"okta.policyRule.lastUpdated": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaPolicyRule).GetLastUpdated()).ToDataRes(types.Time)
	},
	"okta.trustedOrigin.id": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaTrustedOrigin).GetId()).ToDataRes(types.String)
	},
	"okta.trustedOrigin.name": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaTrustedOrigin).GetName()).ToDataRes(types.String)
	},
	"okta.trustedOrigin.origin": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaTrustedOrigin).GetOrigin()).ToDataRes(types.String)
	},
	"okta.trustedOrigin.created": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaTrustedOrigin).GetCreated()).ToDataRes(types.Time)
	},
	"okta.trustedOrigin.createdBy": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaTrustedOrigin).GetCreatedBy()).ToDataRes(types.String)
	},
	"okta.trustedOrigin.lastUpdated": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaTrustedOrigin).GetLastUpdated()).ToDataRes(types.Time)
	},
	"okta.trustedOrigin.lastUpdatedBy": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaTrustedOrigin).GetLastUpdatedBy()).ToDataRes(types.String)
	},
	"okta.trustedOrigin.scopes": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaTrustedOrigin).GetScopes()).ToDataRes(types.Array(types.Dict))
	},
	"okta.trustedOrigin.status": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaTrustedOrigin).GetStatus()).ToDataRes(types.String)
	},
	"okta.network.id": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaNetwork).GetId()).ToDataRes(types.String)
	},
	"okta.network.name": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaNetwork).GetName()).ToDataRes(types.String)
	},
	"okta.network.type": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaNetwork).GetType()).ToDataRes(types.String)
	},
	"okta.network.created": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaNetwork).GetCreated()).ToDataRes(types.Time)
	},
	"okta.network.lastUpdated": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaNetwork).GetLastUpdated()).ToDataRes(types.Time)
	},
	"okta.network.status": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaNetwork).GetStatus()).ToDataRes(types.String)
	},
	"okta.network.system": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaNetwork).GetSystem()).ToDataRes(types.Bool)
	},
	"okta.network.asns": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaNetwork).GetAsns()).ToDataRes(types.Array(types.String))
	},
	"okta.network.usage": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaNetwork).GetUsage()).ToDataRes(types.String)
	},
	"okta.network.proxyType": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaNetwork).GetProxyType()).ToDataRes(types.String)
	},
	"okta.network.proxies": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaNetwork).GetProxies()).ToDataRes(types.Array(types.Dict))
	},
	"okta.network.locations": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaNetwork).GetLocations()).ToDataRes(types.Array(types.Dict))
	},
	"okta.network.gateways": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaNetwork).GetGateways()).ToDataRes(types.Array(types.Dict))
	},
	"okta.threatsConfiguration.action": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaThreatsConfiguration).GetAction()).ToDataRes(types.String)
	},
	"okta.threatsConfiguration.excludeZones": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaThreatsConfiguration).GetExcludeZones()).ToDataRes(types.Array(types.Resource("okta.network")))
	},
	"okta.threatsConfiguration.created": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaThreatsConfiguration).GetCreated()).ToDataRes(types.Time)
	},
	"okta.threatsConfiguration.lastUpdated": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaThreatsConfiguration).GetLastUpdated()).ToDataRes(types.Time)
	},
	"okta.customRole.id": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaCustomRole).GetId()).ToDataRes(types.String)
	},
	"okta.customRole.label": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaCustomRole).GetLabel()).ToDataRes(types.String)
	},
	"okta.customRole.description": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaCustomRole).GetDescription()).ToDataRes(types.String)
	},
	"okta.customRole.permissions": func(r plugin.Resource) *plugin.DataRes {
		return (r.(*mqlOktaCustomRole).GetPermissions()).ToDataRes(types.Array(types.String))
	},
}

func GetData(resource plugin.Resource, field string, args map[string]*llx.RawData) *plugin.DataRes {
	f, ok := getDataFields[resource.MqlName()+"."+field]
	if !ok {
		return &plugin.DataRes{Error: "cannot find '" + field + "' in resource '" + resource.MqlName() + "'"}
	}

	return f(resource)
}

var setDataFields = map[string]func(r plugin.Resource, v *llx.RawData) bool{
	"okta.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOkta).__id, ok = v.Value.(string)
		return
	},
	"okta.users": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOkta).Users, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.groups": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOkta).Groups, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.groupRules": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOkta).GroupRules, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.domains": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOkta).Domains, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.applications": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOkta).Applications, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.trustedOrigins": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOkta).TrustedOrigins, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.networks": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOkta).Networks, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.customRoles": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOkta).CustomRoles, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.organization.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).__id, ok = v.Value.(string)
		return
	},
	"okta.organization.id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).Id, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.organization.companyName": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).CompanyName, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.organization.status": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).Status, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.organization.subdomain": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).Subdomain, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.organization.address1": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).Address1, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.organization.address2": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).Address2, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.organization.city": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).City, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.organization.state": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).State, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.organization.phoneNumber": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).PhoneNumber, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.organization.postalCode": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).PostalCode, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.organization.country": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).Country, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.organization.supportPhoneNumber": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).SupportPhoneNumber, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.organization.website": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).Website, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.organization.endUserSupportHelpURL": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).EndUserSupportHelpURL, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.organization.created": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.organization.lastUpdated": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).LastUpdated, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.organization.expiresAt": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).ExpiresAt, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.organization.optOutCommunicationEmails": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).OptOutCommunicationEmails, ok = plugin.RawToTValue[bool](v.Value, v.Error)
		return
	},
	"okta.organization.billingContact": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).BillingContact, ok = plugin.RawToTValue[*mqlOktaUser](v.Value, v.Error)
		return
	},
	"okta.organization.technicalContact": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).TechnicalContact, ok = plugin.RawToTValue[*mqlOktaUser](v.Value, v.Error)
		return
	},
	"okta.organization.securityNotificationEmails": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).SecurityNotificationEmails, ok = plugin.RawToTValue[any](v.Value, v.Error)
		return
	},
	"okta.organization.threatInsightSettings": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaOrganization).ThreatInsightSettings, ok = plugin.RawToTValue[*mqlOktaThreatsConfiguration](v.Value, v.Error)
		return
	},
	"okta.policies.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicies).__id, ok = v.Value.(string)
		return
	},
	"okta.policies.password": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicies).Password, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.policies.mfaEnroll": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicies).MfaEnroll, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.policies.signOn": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicies).SignOn, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.policies.oauthAuthorizationPolicy": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicies).OauthAuthorizationPolicy, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.policies.idpDiscovery": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicies).IdpDiscovery, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.policies.accessPolicy": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicies).AccessPolicy, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.policies.profileEnrollment": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicies).ProfileEnrollment, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.user.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaUser).__id, ok = v.Value.(string)
		return
	},
	"okta.user.id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaUser).Id, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.user.typeId": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaUser).TypeId, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.user.type": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaUser).Type, ok = plugin.RawToTValue[any](v.Value, v.Error)
		return
	},
	"okta.user.credentials": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaUser).Credentials, ok = plugin.RawToTValue[any](v.Value, v.Error)
		return
	},
	"okta.user.activated": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaUser).Activated, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.user.created": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaUser).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.user.lastLogin": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaUser).LastLogin, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.user.lastUpdated": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaUser).LastUpdated, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.user.passwordChanged": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaUser).PasswordChanged, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.user.profile": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaUser).Profile, ok = plugin.RawToTValue[any](v.Value, v.Error)
		return
	},
	"okta.user.status": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaUser).Status, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.user.statusChanged": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaUser).StatusChanged, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.user.transitioningToStatus": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaUser).TransitioningToStatus, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.user.roles": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaUser).Roles, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.role.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaRole).__id, ok = v.Value.(string)
		return
	},
	"okta.role.id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaRole).Id, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.role.assignmentType": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaRole).AssignmentType, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.role.created": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaRole).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.role.label": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaRole).Label, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.role.lastUpdated": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaRole).LastUpdated, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.role.status": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaRole).Status, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.role.type": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaRole).Type, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.group.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaGroup).__id, ok = v.Value.(string)
		return
	},
	"okta.group.id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaGroup).Id, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.group.name": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaGroup).Name, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.group.description": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaGroup).Description, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.group.type": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaGroup).Type, ok = plugin.RawToTValue[any](v.Value, v.Error)
		return
	},
	"okta.group.created": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaGroup).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.group.lastMembershipUpdated": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaGroup).LastMembershipUpdated, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.group.lastUpdated": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaGroup).LastUpdated, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.group.profile": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaGroup).Profile, ok = plugin.RawToTValue[any](v.Value, v.Error)
		return
	},
	"okta.group.members": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaGroup).Members, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.group.roles": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaGroup).Roles, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.groupRule.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaGroupRule).__id, ok = v.Value.(string)
		return
	},
	"okta.groupRule.id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaGroupRule).Id, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.groupRule.name": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaGroupRule).Name, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.groupRule.status": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaGroupRule).Status, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.groupRule.type": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaGroupRule).Type, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.application.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaApplication).__id, ok = v.Value.(string)
		return
	},
	"okta.application.id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaApplication).Id, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.application.name": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaApplication).Name, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.application.label": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaApplication).Label, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.application.created": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaApplication).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.application.lastUpdated": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaApplication).LastUpdated, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.application.credentials": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaApplication).Credentials, ok = plugin.RawToTValue[any](v.Value, v.Error)
		return
	},
	"okta.application.features": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaApplication).Features, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.application.licensing": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaApplication).Licensing, ok = plugin.RawToTValue[any](v.Value, v.Error)
		return
	},
	"okta.application.profile": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaApplication).Profile, ok = plugin.RawToTValue[any](v.Value, v.Error)
		return
	},
	"okta.application.settings": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaApplication).Settings, ok = plugin.RawToTValue[any](v.Value, v.Error)
		return
	},
	"okta.application.signOnMode": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaApplication).SignOnMode, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.application.status": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaApplication).Status, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.application.visibility": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaApplication).Visibility, ok = plugin.RawToTValue[any](v.Value, v.Error)
		return
	},
	"okta.domain.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaDomain).__id, ok = v.Value.(string)
		return
	},
	"okta.domain.id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaDomain).Id, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.domain.domain": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaDomain).Domain, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.domain.validationStatus": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaDomain).ValidationStatus, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.domain.dnsRecords": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaDomain).DnsRecords, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.domain.publicCertificate": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaDomain).PublicCertificate, ok = plugin.RawToTValue[any](v.Value, v.Error)
		return
	},
	"okta.policy.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicy).__id, ok = v.Value.(string)
		return
	},
	"okta.policy.id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicy).Id, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.policy.name": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicy).Name, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.policy.description": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicy).Description, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.policy.priority": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicy).Priority, ok = plugin.RawToTValue[int64](v.Value, v.Error)
		return
	},
	"okta.policy.status": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicy).Status, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.policy.system": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicy).System, ok = plugin.RawToTValue[bool](v.Value, v.Error)
		return
	},
	"okta.policy.type": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicy).Type, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.policy.conditions": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicy).Conditions, ok = plugin.RawToTValue[any](v.Value, v.Error)
		return
	},
	"okta.policy.settings": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicy).Settings, ok = plugin.RawToTValue[any](v.Value, v.Error)
		return
	},
	"okta.policy.created": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicy).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.policy.lastUpdated": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicy).LastUpdated, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.policy.rules": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicy).Rules, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.policyRule.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicyRule).__id, ok = v.Value.(string)
		return
	},
	"okta.policyRule.id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicyRule).Id, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.policyRule.name": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicyRule).Name, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.policyRule.priority": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicyRule).Priority, ok = plugin.RawToTValue[int64](v.Value, v.Error)
		return
	},
	"okta.policyRule.status": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicyRule).Status, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.policyRule.system": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicyRule).System, ok = plugin.RawToTValue[bool](v.Value, v.Error)
		return
	},
	"okta.policyRule.type": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicyRule).Type, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.policyRule.actions": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicyRule).Actions, ok = plugin.RawToTValue[any](v.Value, v.Error)
		return
	},
	"okta.policyRule.conditions": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicyRule).Conditions, ok = plugin.RawToTValue[any](v.Value, v.Error)
		return
	},
	"okta.policyRule.created": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicyRule).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.policyRule.lastUpdated": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaPolicyRule).LastUpdated, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.trustedOrigin.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaTrustedOrigin).__id, ok = v.Value.(string)
		return
	},
	"okta.trustedOrigin.id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaTrustedOrigin).Id, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.trustedOrigin.name": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaTrustedOrigin).Name, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.trustedOrigin.origin": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaTrustedOrigin).Origin, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.trustedOrigin.created": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaTrustedOrigin).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.trustedOrigin.createdBy": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaTrustedOrigin).CreatedBy, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.trustedOrigin.lastUpdated": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaTrustedOrigin).LastUpdated, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.trustedOrigin.lastUpdatedBy": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaTrustedOrigin).LastUpdatedBy, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.trustedOrigin.scopes": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaTrustedOrigin).Scopes, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.trustedOrigin.status": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaTrustedOrigin).Status, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.network.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaNetwork).__id, ok = v.Value.(string)
		return
	},
	"okta.network.id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaNetwork).Id, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.network.name": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaNetwork).Name, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.network.type": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaNetwork).Type, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.network.created": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaNetwork).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.network.lastUpdated": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaNetwork).LastUpdated, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.network.status": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaNetwork).Status, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.network.system": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaNetwork).System, ok = plugin.RawToTValue[bool](v.Value, v.Error)
		return
	},
	"okta.network.asns": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaNetwork).Asns, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.network.usage": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaNetwork).Usage, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.network.proxyType": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaNetwork).ProxyType, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.network.proxies": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaNetwork).Proxies, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.network.locations": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaNetwork).Locations, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.network.gateways": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaNetwork).Gateways, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.threatsConfiguration.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaThreatsConfiguration).__id, ok = v.Value.(string)
		return
	},
	"okta.threatsConfiguration.action": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaThreatsConfiguration).Action, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.threatsConfiguration.excludeZones": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaThreatsConfiguration).ExcludeZones, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
	"okta.threatsConfiguration.created": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaThreatsConfiguration).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.threatsConfiguration.lastUpdated": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaThreatsConfiguration).LastUpdated, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error)
		return
	},
	"okta.customRole.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaCustomRole).__id, ok = v.Value.(string)
		return
	},
	"okta.customRole.id": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaCustomRole).Id, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.customRole.label": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaCustomRole).Label, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.customRole.description": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaCustomRole).Description, ok = plugin.RawToTValue[string](v.Value, v.Error)
		return
	},
	"okta.customRole.permissions": func(r plugin.Resource, v *llx.RawData) (ok bool) {
		r.(*mqlOktaCustomRole).Permissions, ok = plugin.RawToTValue[[]any](v.Value, v.Error)
		return
	},
}

func SetData(resource plugin.Resource, field string, val *llx.RawData) error {
	f, ok := setDataFields[resource.MqlName()+"."+field]
	if !ok {
		return errors.New("[okta] cannot set '" + field + "' in resource '" + resource.MqlName() + "', field not found")
	}

	if ok := f(resource, val); !ok {
		return errors.New("[okta] cannot set '" + field + "' in resource '" + resource.MqlName() + "', type does not match")
	}
	return nil
}

func SetAllData(resource plugin.Resource, args map[string]*llx.RawData) error {
	var err error
	for k, v := range args {
		if err = SetData(resource, k, v); err != nil {
			return err
		}
	}
	return nil
}

// mqlOkta for the okta resource
type mqlOkta struct {
	MqlRuntime *plugin.Runtime
	__id       string
	// optional: if you define mqlOktaInternal it will be used here
	Users          plugin.TValue[[]any]
	Groups         plugin.TValue[[]any]
	GroupRules     plugin.TValue[[]any]
	Domains        plugin.TValue[[]any]
	Applications   plugin.TValue[[]any]
	TrustedOrigins plugin.TValue[[]any]
	Networks       plugin.TValue[[]any]
	CustomRoles    plugin.TValue[[]any]
}

// createOkta creates a new instance of this resource
func createOkta(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) {
	res := &mqlOkta{
		MqlRuntime: runtime,
	}

	err := SetAllData(res, args)
	if err != nil {
		return res, err
	}

	if res.__id == "" {
		res.__id, err = res.id()
		if err != nil {
			return nil, err
		}
	}

	if runtime.HasRecording {
		args, err = runtime.ResourceFromRecording("okta", res.__id)
		if err != nil || args == nil {
			return res, err
		}
		return res, SetAllData(res, args)
	}

	return res, nil
}

func (c *mqlOkta) MqlName() string {
	return "okta"
}

func (c *mqlOkta) MqlID() string {
	return c.__id
}

func (c *mqlOkta) GetUsers() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.Users, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta", c.__id, "users")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.users()
	})
}

func (c *mqlOkta) GetGroups() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.Groups, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta", c.__id, "groups")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.groups()
	})
}

func (c *mqlOkta) GetGroupRules() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.GroupRules, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta", c.__id, "groupRules")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.groupRules()
	})
}

func (c *mqlOkta) GetDomains() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.Domains, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta", c.__id, "domains")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.domains()
	})
}

func (c *mqlOkta) GetApplications() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.Applications, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta", c.__id, "applications")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.applications()
	})
}

func (c *mqlOkta) GetTrustedOrigins() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.TrustedOrigins, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta", c.__id, "trustedOrigins")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.trustedOrigins()
	})
}

func (c *mqlOkta) GetNetworks() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.Networks, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta", c.__id, "networks")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.networks()
	})
}

func (c *mqlOkta) GetCustomRoles() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.CustomRoles, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta", c.__id, "customRoles")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.customRoles()
	})
}

// mqlOktaOrganization for the okta.organization resource
type mqlOktaOrganization struct {
	MqlRuntime *plugin.Runtime
	__id       string
	// optional: if you define mqlOktaOrganizationInternal it will be used here
	Id                         plugin.TValue[string]
	CompanyName                plugin.TValue[string]
	Status                     plugin.TValue[string]
	Subdomain                  plugin.TValue[string]
	Address1                   plugin.TValue[string]
	Address2                   plugin.TValue[string]
	City                       plugin.TValue[string]
	State                      plugin.TValue[string]
	PhoneNumber                plugin.TValue[string]
	PostalCode                 plugin.TValue[string]
	Country                    plugin.TValue[string]
	SupportPhoneNumber         plugin.TValue[string]
	Website                    plugin.TValue[string]
	EndUserSupportHelpURL      plugin.TValue[string]
	Created                    plugin.TValue[*time.Time]
	LastUpdated                plugin.TValue[*time.Time]
	ExpiresAt                  plugin.TValue[*time.Time]
	OptOutCommunicationEmails  plugin.TValue[bool]
	BillingContact             plugin.TValue[*mqlOktaUser]
	TechnicalContact           plugin.TValue[*mqlOktaUser]
	SecurityNotificationEmails plugin.TValue[any]
	ThreatInsightSettings      plugin.TValue[*mqlOktaThreatsConfiguration]
}

// createOktaOrganization creates a new instance of this resource
func createOktaOrganization(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) {
	res := &mqlOktaOrganization{
		MqlRuntime: runtime,
	}

	err := SetAllData(res, args)
	if err != nil {
		return res, err
	}

	if res.__id == "" {
		res.__id, err = res.id()
		if err != nil {
			return nil, err
		}
	}

	if runtime.HasRecording {
		args, err = runtime.ResourceFromRecording("okta.organization", res.__id)
		if err != nil || args == nil {
			return res, err
		}
		return res, SetAllData(res, args)
	}

	return res, nil
}

func (c *mqlOktaOrganization) MqlName() string {
	return "okta.organization"
}

func (c *mqlOktaOrganization) MqlID() string {
	return c.__id
}

func (c *mqlOktaOrganization) GetId() *plugin.TValue[string] {
	return &c.Id
}

func (c *mqlOktaOrganization) GetCompanyName() *plugin.TValue[string] {
	return &c.CompanyName
}

func (c *mqlOktaOrganization) GetStatus() *plugin.TValue[string] {
	return &c.Status
}

func (c *mqlOktaOrganization) GetSubdomain() *plugin.TValue[string] {
	return &c.Subdomain
}

func (c *mqlOktaOrganization) GetAddress1() *plugin.TValue[string] {
	return &c.Address1
}

func (c *mqlOktaOrganization) GetAddress2() *plugin.TValue[string] {
	return &c.Address2
}

func (c *mqlOktaOrganization) GetCity() *plugin.TValue[string] {
	return &c.City
}

func (c *mqlOktaOrganization) GetState() *plugin.TValue[string] {
	return &c.State
}

func (c *mqlOktaOrganization) GetPhoneNumber() *plugin.TValue[string] {
	return &c.PhoneNumber
}

func (c *mqlOktaOrganization) GetPostalCode() *plugin.TValue[string] {
	return &c.PostalCode
}

func (c *mqlOktaOrganization) GetCountry() *plugin.TValue[string] {
	return &c.Country
}

func (c *mqlOktaOrganization) GetSupportPhoneNumber() *plugin.TValue[string] {
	return &c.SupportPhoneNumber
}

func (c *mqlOktaOrganization) GetWebsite() *plugin.TValue[string] {
	return &c.Website
}

func (c *mqlOktaOrganization) GetEndUserSupportHelpURL() *plugin.TValue[string] {
	return &c.EndUserSupportHelpURL
}

func (c *mqlOktaOrganization) GetCreated() *plugin.TValue[*time.Time] {
	return &c.Created
}

func (c *mqlOktaOrganization) GetLastUpdated() *plugin.TValue[*time.Time] {
	return &c.LastUpdated
}

func (c *mqlOktaOrganization) GetExpiresAt() *plugin.TValue[*time.Time] {
	return &c.ExpiresAt
}

func (c *mqlOktaOrganization) GetOptOutCommunicationEmails() *plugin.TValue[bool] {
	return plugin.GetOrCompute[bool](&c.OptOutCommunicationEmails, func() (bool, error) {
		return c.optOutCommunicationEmails()
	})
}

func (c *mqlOktaOrganization) GetBillingContact() *plugin.TValue[*mqlOktaUser] {
	return plugin.GetOrCompute[*mqlOktaUser](&c.BillingContact, func() (*mqlOktaUser, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta.organization", c.__id, "billingContact")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.(*mqlOktaUser), nil
			}
		}

		return c.billingContact()
	})
}

func (c *mqlOktaOrganization) GetTechnicalContact() *plugin.TValue[*mqlOktaUser] {
	return plugin.GetOrCompute[*mqlOktaUser](&c.TechnicalContact, func() (*mqlOktaUser, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta.organization", c.__id, "technicalContact")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.(*mqlOktaUser), nil
			}
		}

		return c.technicalContact()
	})
}

func (c *mqlOktaOrganization) GetSecurityNotificationEmails() *plugin.TValue[any] {
	return plugin.GetOrCompute[any](&c.SecurityNotificationEmails, func() (any, error) {
		return c.securityNotificationEmails()
	})
}

func (c *mqlOktaOrganization) GetThreatInsightSettings() *plugin.TValue[*mqlOktaThreatsConfiguration] {
	return plugin.GetOrCompute[*mqlOktaThreatsConfiguration](&c.ThreatInsightSettings, func() (*mqlOktaThreatsConfiguration, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta.organization", c.__id, "threatInsightSettings")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.(*mqlOktaThreatsConfiguration), nil
			}
		}

		return c.threatInsightSettings()
	})
}

// mqlOktaPolicies for the okta.policies resource
type mqlOktaPolicies struct {
	MqlRuntime *plugin.Runtime
	__id       string
	// optional: if you define mqlOktaPoliciesInternal it will be used here
	Password                 plugin.TValue[[]any]
	MfaEnroll                plugin.TValue[[]any]
	SignOn                   plugin.TValue[[]any]
	OauthAuthorizationPolicy plugin.TValue[[]any]
	IdpDiscovery             plugin.TValue[[]any]
	AccessPolicy             plugin.TValue[[]any]
	ProfileEnrollment        plugin.TValue[[]any]
}

// createOktaPolicies creates a new instance of this resource
func createOktaPolicies(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) {
	res := &mqlOktaPolicies{
		MqlRuntime: runtime,
	}

	err := SetAllData(res, args)
	if err != nil {
		return res, err
	}

	if res.__id == "" {
		res.__id, err = res.id()
		if err != nil {
			return nil, err
		}
	}

	if runtime.HasRecording {
		args, err = runtime.ResourceFromRecording("okta.policies", res.__id)
		if err != nil || args == nil {
			return res, err
		}
		return res, SetAllData(res, args)
	}

	return res, nil
}

func (c *mqlOktaPolicies) MqlName() string {
	return "okta.policies"
}

func (c *mqlOktaPolicies) MqlID() string {
	return c.__id
}

func (c *mqlOktaPolicies) GetPassword() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.Password, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta.policies", c.__id, "password")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.password()
	})
}

func (c *mqlOktaPolicies) GetMfaEnroll() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.MfaEnroll, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta.policies", c.__id, "mfaEnroll")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.mfaEnroll()
	})
}

func (c *mqlOktaPolicies) GetSignOn() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.SignOn, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta.policies", c.__id, "signOn")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.signOn()
	})
}

func (c *mqlOktaPolicies) GetOauthAuthorizationPolicy() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.OauthAuthorizationPolicy, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta.policies", c.__id, "oauthAuthorizationPolicy")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.oauthAuthorizationPolicy()
	})
}

func (c *mqlOktaPolicies) GetIdpDiscovery() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.IdpDiscovery, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta.policies", c.__id, "idpDiscovery")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.idpDiscovery()
	})
}

func (c *mqlOktaPolicies) GetAccessPolicy() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.AccessPolicy, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta.policies", c.__id, "accessPolicy")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.accessPolicy()
	})
}

func (c *mqlOktaPolicies) GetProfileEnrollment() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.ProfileEnrollment, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta.policies", c.__id, "profileEnrollment")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.profileEnrollment()
	})
}

// mqlOktaUser for the okta.user resource
type mqlOktaUser struct {
	MqlRuntime *plugin.Runtime
	__id       string
	// optional: if you define mqlOktaUserInternal it will be used here
	Id                    plugin.TValue[string]
	TypeId                plugin.TValue[string]
	Type                  plugin.TValue[any]
	Credentials           plugin.TValue[any]
	Activated             plugin.TValue[*time.Time]
	Created               plugin.TValue[*time.Time]
	LastLogin             plugin.TValue[*time.Time]
	LastUpdated           plugin.TValue[*time.Time]
	PasswordChanged       plugin.TValue[*time.Time]
	Profile               plugin.TValue[any]
	Status                plugin.TValue[string]
	StatusChanged         plugin.TValue[*time.Time]
	TransitioningToStatus plugin.TValue[string]
	Roles                 plugin.TValue[[]any]
}

// createOktaUser creates a new instance of this resource
func createOktaUser(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) {
	res := &mqlOktaUser{
		MqlRuntime: runtime,
	}

	err := SetAllData(res, args)
	if err != nil {
		return res, err
	}

	if res.__id == "" {
		res.__id, err = res.id()
		if err != nil {
			return nil, err
		}
	}

	if runtime.HasRecording {
		args, err = runtime.ResourceFromRecording("okta.user", res.__id)
		if err != nil || args == nil {
			return res, err
		}
		return res, SetAllData(res, args)
	}

	return res, nil
}

func (c *mqlOktaUser) MqlName() string {
	return "okta.user"
}

func (c *mqlOktaUser) MqlID() string {
	return c.__id
}

func (c *mqlOktaUser) GetId() *plugin.TValue[string] {
	return &c.Id
}

func (c *mqlOktaUser) GetTypeId() *plugin.TValue[string] {
	return &c.TypeId
}

func (c *mqlOktaUser) GetType() *plugin.TValue[any] {
	return &c.Type
}

func (c *mqlOktaUser) GetCredentials() *plugin.TValue[any] {
	return &c.Credentials
}

func (c *mqlOktaUser) GetActivated() *plugin.TValue[*time.Time] {
	return &c.Activated
}

func (c *mqlOktaUser) GetCreated() *plugin.TValue[*time.Time] {
	return &c.Created
}

func (c *mqlOktaUser) GetLastLogin() *plugin.TValue[*time.Time] {
	return &c.LastLogin
}

func (c *mqlOktaUser) GetLastUpdated() *plugin.TValue[*time.Time] {
	return &c.LastUpdated
}

func (c *mqlOktaUser) GetPasswordChanged() *plugin.TValue[*time.Time] {
	return &c.PasswordChanged
}

func (c *mqlOktaUser) GetProfile() *plugin.TValue[any] {
	return &c.Profile
}

func (c *mqlOktaUser) GetStatus() *plugin.TValue[string] {
	return &c.Status
}

func (c *mqlOktaUser) GetStatusChanged() *plugin.TValue[*time.Time] {
	return &c.StatusChanged
}

func (c *mqlOktaUser) GetTransitioningToStatus() *plugin.TValue[string] {
	return &c.TransitioningToStatus
}

func (c *mqlOktaUser) GetRoles() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.Roles, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta.user", c.__id, "roles")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.roles()
	})
}

// mqlOktaRole for the okta.role resource
type mqlOktaRole struct {
	MqlRuntime *plugin.Runtime
	__id       string
	// optional: if you define mqlOktaRoleInternal it will be used here
	Id             plugin.TValue[string]
	AssignmentType plugin.TValue[string]
	Created        plugin.TValue[*time.Time]
	Label          plugin.TValue[string]
	LastUpdated    plugin.TValue[*time.Time]
	Status         plugin.TValue[string]
	Type           plugin.TValue[string]
}

// createOktaRole creates a new instance of this resource
func createOktaRole(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) {
	res := &mqlOktaRole{
		MqlRuntime: runtime,
	}

	err := SetAllData(res, args)
	if err != nil {
		return res, err
	}

	if res.__id == "" {
		res.__id, err = res.id()
		if err != nil {
			return nil, err
		}
	}

	if runtime.HasRecording {
		args, err = runtime.ResourceFromRecording("okta.role", res.__id)
		if err != nil || args == nil {
			return res, err
		}
		return res, SetAllData(res, args)
	}

	return res, nil
}

func (c *mqlOktaRole) MqlName() string {
	return "okta.role"
}

func (c *mqlOktaRole) MqlID() string {
	return c.__id
}

func (c *mqlOktaRole) GetId() *plugin.TValue[string] {
	return &c.Id
}

func (c *mqlOktaRole) GetAssignmentType() *plugin.TValue[string] {
	return &c.AssignmentType
}

func (c *mqlOktaRole) GetCreated() *plugin.TValue[*time.Time] {
	return &c.Created
}

func (c *mqlOktaRole) GetLabel() *plugin.TValue[string] {
	return &c.Label
}

func (c *mqlOktaRole) GetLastUpdated() *plugin.TValue[*time.Time] {
	return &c.LastUpdated
}

func (c *mqlOktaRole) GetStatus() *plugin.TValue[string] {
	return &c.Status
}

func (c *mqlOktaRole) GetType() *plugin.TValue[string] {
	return &c.Type
}

// mqlOktaGroup for the okta.group resource
type mqlOktaGroup struct {
	MqlRuntime *plugin.Runtime
	__id       string
	// optional: if you define mqlOktaGroupInternal it will be used here
	Id                    plugin.TValue[string]
	Name                  plugin.TValue[string]
	Description           plugin.TValue[string]
	Type                  plugin.TValue[any]
	Created               plugin.TValue[*time.Time]
	LastMembershipUpdated plugin.TValue[*time.Time]
	LastUpdated           plugin.TValue[*time.Time]
	Profile               plugin.TValue[any]
	Members               plugin.TValue[[]any]
	Roles                 plugin.TValue[[]any]
}

// createOktaGroup creates a new instance of this resource
func createOktaGroup(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) {
	res := &mqlOktaGroup{
		MqlRuntime: runtime,
	}

	err := SetAllData(res, args)
	if err != nil {
		return res, err
	}

	if res.__id == "" {
		res.__id, err = res.id()
		if err != nil {
			return nil, err
		}
	}

	if runtime.HasRecording {
		args, err = runtime.ResourceFromRecording("okta.group", res.__id)
		if err != nil || args == nil {
			return res, err
		}
		return res, SetAllData(res, args)
	}

	return res, nil
}

func (c *mqlOktaGroup) MqlName() string {
	return "okta.group"
}

func (c *mqlOktaGroup) MqlID() string {
	return c.__id
}

func (c *mqlOktaGroup) GetId() *plugin.TValue[string] {
	return &c.Id
}

func (c *mqlOktaGroup) GetName() *plugin.TValue[string] {
	return &c.Name
}

func (c *mqlOktaGroup) GetDescription() *plugin.TValue[string] {
	return &c.Description
}

func (c *mqlOktaGroup) GetType() *plugin.TValue[any] {
	return &c.Type
}

func (c *mqlOktaGroup) GetCreated() *plugin.TValue[*time.Time] {
	return &c.Created
}

func (c *mqlOktaGroup) GetLastMembershipUpdated() *plugin.TValue[*time.Time] {
	return &c.LastMembershipUpdated
}

func (c *mqlOktaGroup) GetLastUpdated() *plugin.TValue[*time.Time] {
	return &c.LastUpdated
}

func (c *mqlOktaGroup) GetProfile() *plugin.TValue[any] {
	return &c.Profile
}

func (c *mqlOktaGroup) GetMembers() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.Members, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta.group", c.__id, "members")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.members()
	})
}

func (c *mqlOktaGroup) GetRoles() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.Roles, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta.group", c.__id, "roles")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.roles()
	})
}

// mqlOktaGroupRule for the okta.groupRule resource
type mqlOktaGroupRule struct {
	MqlRuntime *plugin.Runtime
	__id       string
	// optional: if you define mqlOktaGroupRuleInternal it will be used here
	Id     plugin.TValue[string]
	Name   plugin.TValue[string]
	Status plugin.TValue[string]
	Type   plugin.TValue[string]
}

// createOktaGroupRule creates a new instance of this resource
func createOktaGroupRule(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) {
	res := &mqlOktaGroupRule{
		MqlRuntime: runtime,
	}

	err := SetAllData(res, args)
	if err != nil {
		return res, err
	}

	// to override __id implement: id() (string, error)

	if runtime.HasRecording {
		args, err = runtime.ResourceFromRecording("okta.groupRule", res.__id)
		if err != nil || args == nil {
			return res, err
		}
		return res, SetAllData(res, args)
	}

	return res, nil
}

func (c *mqlOktaGroupRule) MqlName() string {
	return "okta.groupRule"
}

func (c *mqlOktaGroupRule) MqlID() string {
	return c.__id
}

func (c *mqlOktaGroupRule) GetId() *plugin.TValue[string] {
	return &c.Id
}

func (c *mqlOktaGroupRule) GetName() *plugin.TValue[string] {
	return &c.Name
}

func (c *mqlOktaGroupRule) GetStatus() *plugin.TValue[string] {
	return &c.Status
}

func (c *mqlOktaGroupRule) GetType() *plugin.TValue[string] {
	return &c.Type
}

// mqlOktaApplication for the okta.application resource
type mqlOktaApplication struct {
	MqlRuntime *plugin.Runtime
	__id       string
	// optional: if you define mqlOktaApplicationInternal it will be used here
	Id          plugin.TValue[string]
	Name        plugin.TValue[string]
	Label       plugin.TValue[string]
	Created     plugin.TValue[*time.Time]
	LastUpdated plugin.TValue[*time.Time]
	Credentials plugin.TValue[any]
	Features    plugin.TValue[[]any]
	Licensing   plugin.TValue[any]
	Profile     plugin.TValue[any]
	Settings    plugin.TValue[any]
	SignOnMode  plugin.TValue[string]
	Status      plugin.TValue[string]
	Visibility  plugin.TValue[any]
}

// createOktaApplication creates a new instance of this resource
func createOktaApplication(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) {
	res := &mqlOktaApplication{
		MqlRuntime: runtime,
	}

	err := SetAllData(res, args)
	if err != nil {
		return res, err
	}

	if res.__id == "" {
		res.__id, err = res.id()
		if err != nil {
			return nil, err
		}
	}

	if runtime.HasRecording {
		args, err = runtime.ResourceFromRecording("okta.application", res.__id)
		if err != nil || args == nil {
			return res, err
		}
		return res, SetAllData(res, args)
	}

	return res, nil
}

func (c *mqlOktaApplication) MqlName() string {
	return "okta.application"
}

func (c *mqlOktaApplication) MqlID() string {
	return c.__id
}

func (c *mqlOktaApplication) GetId() *plugin.TValue[string] {
	return &c.Id
}

func (c *mqlOktaApplication) GetName() *plugin.TValue[string] {
	return &c.Name
}

func (c *mqlOktaApplication) GetLabel() *plugin.TValue[string] {
	return &c.Label
}

func (c *mqlOktaApplication) GetCreated() *plugin.TValue[*time.Time] {
	return &c.Created
}

func (c *mqlOktaApplication) GetLastUpdated() *plugin.TValue[*time.Time] {
	return &c.LastUpdated
}

func (c *mqlOktaApplication) GetCredentials() *plugin.TValue[any] {
	return &c.Credentials
}

func (c *mqlOktaApplication) GetFeatures() *plugin.TValue[[]any] {
	return &c.Features
}

func (c *mqlOktaApplication) GetLicensing() *plugin.TValue[any] {
	return &c.Licensing
}

func (c *mqlOktaApplication) GetProfile() *plugin.TValue[any] {
	return &c.Profile
}

func (c *mqlOktaApplication) GetSettings() *plugin.TValue[any] {
	return &c.Settings
}

func (c *mqlOktaApplication) GetSignOnMode() *plugin.TValue[string] {
	return &c.SignOnMode
}

func (c *mqlOktaApplication) GetStatus() *plugin.TValue[string] {
	return &c.Status
}

func (c *mqlOktaApplication) GetVisibility() *plugin.TValue[any] {
	return &c.Visibility
}

// mqlOktaDomain for the okta.domain resource
type mqlOktaDomain struct {
	MqlRuntime *plugin.Runtime
	__id       string
	// optional: if you define mqlOktaDomainInternal it will be used here
	Id                plugin.TValue[string]
	Domain            plugin.TValue[string]
	ValidationStatus  plugin.TValue[string]
	DnsRecords        plugin.TValue[[]any]
	PublicCertificate plugin.TValue[any]
}

// createOktaDomain creates a new instance of this resource
func createOktaDomain(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) {
	res := &mqlOktaDomain{
		MqlRuntime: runtime,
	}

	err := SetAllData(res, args)
	if err != nil {
		return res, err
	}

	if res.__id == "" {
		res.__id, err = res.id()
		if err != nil {
			return nil, err
		}
	}

	if runtime.HasRecording {
		args, err = runtime.ResourceFromRecording("okta.domain", res.__id)
		if err != nil || args == nil {
			return res, err
		}
		return res, SetAllData(res, args)
	}

	return res, nil
}

func (c *mqlOktaDomain) MqlName() string {
	return "okta.domain"
}

func (c *mqlOktaDomain) MqlID() string {
	return c.__id
}

func (c *mqlOktaDomain) GetId() *plugin.TValue[string] {
	return &c.Id
}

func (c *mqlOktaDomain) GetDomain() *plugin.TValue[string] {
	return &c.Domain
}

func (c *mqlOktaDomain) GetValidationStatus() *plugin.TValue[string] {
	return &c.ValidationStatus
}

func (c *mqlOktaDomain) GetDnsRecords() *plugin.TValue[[]any] {
	return &c.DnsRecords
}

func (c *mqlOktaDomain) GetPublicCertificate() *plugin.TValue[any] {
	return &c.PublicCertificate
}

// mqlOktaPolicy for the okta.policy resource
type mqlOktaPolicy struct {
	MqlRuntime *plugin.Runtime
	__id       string
	// optional: if you define mqlOktaPolicyInternal it will be used here
	Id          plugin.TValue[string]
	Name        plugin.TValue[string]
	Description plugin.TValue[string]
	Priority    plugin.TValue[int64]
	Status      plugin.TValue[string]
	System      plugin.TValue[bool]
	Type        plugin.TValue[string]
	Conditions  plugin.TValue[any]
	Settings    plugin.TValue[any]
	Created     plugin.TValue[*time.Time]
	LastUpdated plugin.TValue[*time.Time]
	Rules       plugin.TValue[[]any]
}

// createOktaPolicy creates a new instance of this resource
func createOktaPolicy(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) {
	res := &mqlOktaPolicy{
		MqlRuntime: runtime,
	}

	err := SetAllData(res, args)
	if err != nil {
		return res, err
	}

	if res.__id == "" {
		res.__id, err = res.id()
		if err != nil {
			return nil, err
		}
	}

	if runtime.HasRecording {
		args, err = runtime.ResourceFromRecording("okta.policy", res.__id)
		if err != nil || args == nil {
			return res, err
		}
		return res, SetAllData(res, args)
	}

	return res, nil
}

func (c *mqlOktaPolicy) MqlName() string {
	return "okta.policy"
}

func (c *mqlOktaPolicy) MqlID() string {
	return c.__id
}

func (c *mqlOktaPolicy) GetId() *plugin.TValue[string] {
	return &c.Id
}

func (c *mqlOktaPolicy) GetName() *plugin.TValue[string] {
	return &c.Name
}

func (c *mqlOktaPolicy) GetDescription() *plugin.TValue[string] {
	return &c.Description
}

func (c *mqlOktaPolicy) GetPriority() *plugin.TValue[int64] {
	return &c.Priority
}

func (c *mqlOktaPolicy) GetStatus() *plugin.TValue[string] {
	return &c.Status
}

func (c *mqlOktaPolicy) GetSystem() *plugin.TValue[bool] {
	return &c.System
}

func (c *mqlOktaPolicy) GetType() *plugin.TValue[string] {
	return &c.Type
}

func (c *mqlOktaPolicy) GetConditions() *plugin.TValue[any] {
	return &c.Conditions
}

func (c *mqlOktaPolicy) GetSettings() *plugin.TValue[any] {
	return &c.Settings
}

func (c *mqlOktaPolicy) GetCreated() *plugin.TValue[*time.Time] {
	return &c.Created
}

func (c *mqlOktaPolicy) GetLastUpdated() *plugin.TValue[*time.Time] {
	return &c.LastUpdated
}

func (c *mqlOktaPolicy) GetRules() *plugin.TValue[[]any] {
	return plugin.GetOrCompute[[]any](&c.Rules, func() ([]any, error) {
		if c.MqlRuntime.HasRecording {
			d, err := c.MqlRuntime.FieldResourceFromRecording("okta.policy", c.__id, "rules")
			if err != nil {
				return nil, err
			}
			if d != nil {
				return d.Value.([]any), nil
			}
		}

		return c.rules()
	})
}

// mqlOktaPolicyRule for the okta.policyRule resource
type mqlOktaPolicyRule struct {
	MqlRuntime *plugin.Runtime
	__id       string
	// optional: if you define mqlOktaPolicyRuleInternal it will be used here
	Id          plugin.TValue[string]
	Name        plugin.TValue[string]
	Priority    plugin.TValue[int64]
	Status      plugin.TValue[string]
	System      plugin.TValue[bool]
	Type        plugin.TValue[string]
	Actions     plugin.TValue[any]
	Conditions  plugin.TValue[any]
	Created     plugin.TValue[*time.Time]
	LastUpdated plugin.TValue[*time.Time]
}

// createOktaPolicyRule creates a new instance of this resource
func createOktaPolicyRule(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) {
	res := &mqlOktaPolicyRule{
		MqlRuntime: runtime,
	}

	err := SetAllData(res, args)
	if err != nil {
		return res, err
	}

	if res.__id == "" {
		res.__id, err = res.id()
		if err != nil {
			return nil, err
		}
	}

	if runtime.HasRecording {
		args, err = runtime.ResourceFromRecording("okta.policyRule", res.__id)
		if err != nil || args == nil {
			return res, err
		}
		return res, SetAllData(res, args)
	}

	return res, nil
}

func (c *mqlOktaPolicyRule) MqlName() string {
	return "okta.policyRule"
}

func (c *mqlOktaPolicyRule) MqlID() string {
	return c.__id
}

func (c *mqlOktaPolicyRule) GetId() *plugin.TValue[string] {
	return &c.Id
}

func (c *mqlOktaPolicyRule) GetName() *plugin.TValue[string] {
	return &c.Name
}

func (c *mqlOktaPolicyRule) GetPriority() *plugin.TValue[int64] {
	return &c.Priority
}

func (c *mqlOktaPolicyRule) GetStatus() *plugin.TValue[string] {
	return &c.Status
}

func (c *mqlOktaPolicyRule) GetSystem() *plugin.TValue[bool] {
	return &c.System
}

func (c *mqlOktaPolicyRule) GetType() *plugin.TValue[string] {
	return &c.Type
}

func (c *mqlOktaPolicyRule) GetActions() *plugin.TValue[any] {
	return &c.Actions
}

func (c *mqlOktaPolicyRule) GetConditions() *plugin.TValue[any] {
	return &c.Conditions
}

func (c *mqlOktaPolicyRule) GetCreated() *plugin.TValue[*time.Time] {
	return &c.Created
}

func (c *mqlOktaPolicyRule) GetLastUpdated() *plugin.TValue[*time.Time] {
	return &c.LastUpdated
}

// mqlOktaTrustedOrigin for the okta.trustedOrigin resource
type mqlOktaTrustedOrigin struct {
	MqlRuntime *plugin.Runtime
	__id       string
	// optional: if you define mqlOktaTrustedOriginInternal it will be used here
	Id            plugin.TValue[string]
	Name          plugin.TValue[string]
	Origin        plugin.TValue[string]
	Created       plugin.TValue[*time.Time]
	CreatedBy     plugin.TValue[string]
	LastUpdated   plugin.TValue[*time.Time]
	LastUpdatedBy plugin.TValue[string]
	Scopes        plugin.TValue[[]any]
	Status        plugin.TValue[string]
}

// createOktaTrustedOrigin creates a new instance of this resource
func createOktaTrustedOrigin(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) {
	res := &mqlOktaTrustedOrigin{
		MqlRuntime: runtime,
	}

	err := SetAllData(res, args)
	if err != nil {
		return res, err
	}

	if res.__id == "" {
		res.__id, err = res.id()
		if err != nil {
			return nil, err
		}
	}

	if runtime.HasRecording {
		args, err = runtime.ResourceFromRecording("okta.trustedOrigin", res.__id)
		if err != nil || args == nil {
			return res, err
		}
		return res, SetAllData(res, args)
	}

	return res, nil
}

func (c *mqlOktaTrustedOrigin) MqlName() string {
	return "okta.trustedOrigin"
}

func (c *mqlOktaTrustedOrigin) MqlID() string {
	return c.__id
}

func (c *mqlOktaTrustedOrigin) GetId() *plugin.TValue[string] {
	return &c.Id
}

func (c *mqlOktaTrustedOrigin) GetName() *plugin.TValue[string] {
	return &c.Name
}

func (c *mqlOktaTrustedOrigin) GetOrigin() *plugin.TValue[string] {
	return &c.Origin
}

func (c *mqlOktaTrustedOrigin) GetCreated() *plugin.TValue[*time.Time] {
	return &c.Created
}

func (c *mqlOktaTrustedOrigin) GetCreatedBy() *plugin.TValue[string] {
	return &c.CreatedBy
}

func (c *mqlOktaTrustedOrigin) GetLastUpdated() *plugin.TValue[*time.Time] {
	return &c.LastUpdated
}

func (c *mqlOktaTrustedOrigin) GetLastUpdatedBy() *plugin.TValue[string] {
	return &c.LastUpdatedBy
}

func (c *mqlOktaTrustedOrigin) GetScopes() *plugin.TValue[[]any] {
	return &c.Scopes
}

func (c *mqlOktaTrustedOrigin) GetStatus() *plugin.TValue[string] {
	return &c.Status
}

// mqlOktaNetwork for the okta.network resource
type mqlOktaNetwork struct {
	MqlRuntime *plugin.Runtime
	__id       string
	// optional: if you define mqlOktaNetworkInternal it will be used here
	Id          plugin.TValue[string]
	Name        plugin.TValue[string]
	Type        plugin.TValue[string]
	Created     plugin.TValue[*time.Time]
	LastUpdated plugin.TValue[*time.Time]
	Status      plugin.TValue[string]
	System      plugin.TValue[bool]
	Asns        plugin.TValue[[]any]
	Usage       plugin.TValue[string]
	ProxyType   plugin.TValue[string]
	Proxies     plugin.TValue[[]any]
	Locations   plugin.TValue[[]any]
	Gateways    plugin.TValue[[]any]
}

// createOktaNetwork creates a new instance of this resource
func createOktaNetwork(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) {
	res := &mqlOktaNetwork{
		MqlRuntime: runtime,
	}

	err := SetAllData(res, args)
	if err != nil {
		return res, err
	}

	if res.__id == "" {
		res.__id, err = res.id()
		if err != nil {
			return nil, err
		}
	}

	if runtime.HasRecording {
		args, err = runtime.ResourceFromRecording("okta.network", res.__id)
		if err != nil || args == nil {
			return res, err
		}
		return res, SetAllData(res, args)
	}

	return res, nil
}

func (c *mqlOktaNetwork) MqlName() string {
	return "okta.network"
}

func (c *mqlOktaNetwork) MqlID() string {
	return c.__id
}

func (c *mqlOktaNetwork) GetId() *plugin.TValue[string] {
	return &c.Id
}

func (c *mqlOktaNetwork) GetName() *plugin.TValue[string] {
	return &c.Name
}

func (c *mqlOktaNetwork) GetType() *plugin.TValue[string] {
	return &c.Type
}

func (c *mqlOktaNetwork) GetCreated() *plugin.TValue[*time.Time] {
	return &c.Created
}

func (c *mqlOktaNetwork) GetLastUpdated() *plugin.TValue[*time.Time] {
	return &c.LastUpdated
}

func (c *mqlOktaNetwork) GetStatus() *plugin.TValue[string] {
	return &c.Status
}

func (c *mqlOktaNetwork) GetSystem() *plugin.TValue[bool] {
	return &c.System
}

func (c *mqlOktaNetwork) GetAsns() *plugin.TValue[[]any] {
	return &c.Asns
}

func (c *mqlOktaNetwork) GetUsage() *plugin.TValue[string] {
	return &c.Usage
}

func (c *mqlOktaNetwork) GetProxyType() *plugin.TValue[string] {
	return &c.ProxyType
}

func (c *mqlOktaNetwork) GetProxies() *plugin.TValue[[]any] {
	return &c.Proxies
}

func (c *mqlOktaNetwork) GetLocations() *plugin.TValue[[]any] {
	return &c.Locations
}

func (c *mqlOktaNetwork) GetGateways() *plugin.TValue[[]any] {
	return &c.Gateways
}

// mqlOktaThreatsConfiguration for the okta.threatsConfiguration resource
type mqlOktaThreatsConfiguration struct {
	MqlRuntime *plugin.Runtime
	__id       string
	// optional: if you define mqlOktaThreatsConfigurationInternal it will be used here
	Action       plugin.TValue[string]
	ExcludeZones plugin.TValue[[]any]
	Created      plugin.TValue[*time.Time]
	LastUpdated  plugin.TValue[*time.Time]
}

// createOktaThreatsConfiguration creates a new instance of this resource
func createOktaThreatsConfiguration(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) {
	res := &mqlOktaThreatsConfiguration{
		MqlRuntime: runtime,
	}

	err := SetAllData(res, args)
	if err != nil {
		return res, err
	}

	if res.__id == "" {
		res.__id, err = res.id()
		if err != nil {
			return nil, err
		}
	}

	if runtime.HasRecording {
		args, err = runtime.ResourceFromRecording("okta.threatsConfiguration", res.__id)
		if err != nil || args == nil {
			return res, err
		}
		return res, SetAllData(res, args)
	}

	return res, nil
}

func (c *mqlOktaThreatsConfiguration) MqlName() string {
	return "okta.threatsConfiguration"
}

func (c *mqlOktaThreatsConfiguration) MqlID() string {
	return c.__id
}

func (c *mqlOktaThreatsConfiguration) GetAction() *plugin.TValue[string] {
	return &c.Action
}

func (c *mqlOktaThreatsConfiguration) GetExcludeZones() *plugin.TValue[[]any] {
	return &c.ExcludeZones
}

func (c *mqlOktaThreatsConfiguration) GetCreated() *plugin.TValue[*time.Time] {
	return &c.Created
}

func (c *mqlOktaThreatsConfiguration) GetLastUpdated() *plugin.TValue[*time.Time] {
	return &c.LastUpdated
}

// mqlOktaCustomRole for the okta.customRole resource
type mqlOktaCustomRole struct {
	MqlRuntime *plugin.Runtime
	__id       string
	// optional: if you define mqlOktaCustomRoleInternal it will be used here
	Id          plugin.TValue[string]
	Label       plugin.TValue[string]
	Description plugin.TValue[string]
	Permissions plugin.TValue[[]any]
}

// createOktaCustomRole creates a new instance of this resource
func createOktaCustomRole(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) {
	res := &mqlOktaCustomRole{
		MqlRuntime: runtime,
	}

	err := SetAllData(res, args)
	if err != nil {
		return res, err
	}

	// to override __id implement: id() (string, error)

	if runtime.HasRecording {
		args, err = runtime.ResourceFromRecording("okta.customRole", res.__id)
		if err != nil || args == nil {
			return res, err
		}
		return res, SetAllData(res, args)
	}

	return res, nil
}

func (c *mqlOktaCustomRole) MqlName() string {
	return "okta.customRole"
}

func (c *mqlOktaCustomRole) MqlID() string {
	return c.__id
}

func (c *mqlOktaCustomRole) GetId() *plugin.TValue[string] {
	return &c.Id
}

func (c *mqlOktaCustomRole) GetLabel() *plugin.TValue[string] {
	return &c.Label
}

func (c *mqlOktaCustomRole) GetDescription() *plugin.TValue[string] {
	return &c.Description
}

func (c *mqlOktaCustomRole) GetPermissions() *plugin.TValue[[]any] {
	return &c.Permissions
}