userstore

var IdpColumnConsentedPurposesAttrTypes = map[string]attr.Type{
	"column": types.StringType,
	"consented_purposes": types.ListType{
		ElemType: types.StringType,
	},
}

var IdpColumnConsentedPurposesAttributes = map[string]schema.Attribute{
	"column": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"consented_purposes": schema.ListAttribute{
		ElementType:         types.StringType,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var IdpColumnRetentionDurationAttrTypes = map[string]attr.Type{
	"column_id": types.StringType,
	"default_duration": types.ObjectType{
		AttrTypes: IdpRetentionDurationAttrTypes,
	},
	"duration": types.ObjectType{
		AttrTypes: IdpRetentionDurationAttrTypes,
	},
	"duration_type": types.StringType,
	"id":            types.StringType,
	"purpose_id":    types.StringType,
	"purpose_name":  types.StringType,
	"use_default":   types.BoolType,
	"version":       types.Int64Type,
}

var IdpColumnRetentionDurationAttributes = map[string]schema.Attribute{
	"column_id": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"default_duration": schema.SingleNestedAttribute{
		Attributes:          IdpRetentionDurationAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
	},
	"duration": schema.SingleNestedAttribute{
		Attributes:          IdpRetentionDurationAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"duration_type": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.OneOf([]string{"", "live", "postdelete", "predelete", "softdeleted"}...),
		},
		Computed:            true,
		Description:         "Valid values: `live`, `postdelete`, `predelete`, `softdeleted`",
		MarkdownDescription: "Valid values: `live`, `postdelete`, `predelete`, `softdeleted`",
		Optional:            true,
	},
	"id": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
		PlanModifiers: []planmodifier.String{
			stringplanmodifier.UseStateForUnknown(),
		},
	},
	"purpose_id": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"purpose_name": schema.StringAttribute{
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
	},
	"use_default": schema.BoolAttribute{
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
	},
	"version": schema.Int64Attribute{
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		PlanModifiers: []planmodifier.Int64{
			planmodifiers.IncrementOnUpdate(),
		},
	},
}

var IdpColumnRetentionDurationResponseAttrTypes = map[string]attr.Type{
	"max_duration": types.ObjectType{
		AttrTypes: IdpRetentionDurationAttrTypes,
	},
	"retention_duration": types.ObjectType{
		AttrTypes: IdpColumnRetentionDurationAttrTypes,
	},
}

var IdpColumnRetentionDurationResponseAttributes = map[string]schema.Attribute{
	"max_duration": schema.SingleNestedAttribute{
		Attributes:          IdpRetentionDurationAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"retention_duration": schema.SingleNestedAttribute{
		Attributes:          IdpColumnRetentionDurationAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var IdpColumnRetentionDurationsResponseAttrTypes = map[string]attr.Type{
	"max_duration": types.ObjectType{
		AttrTypes: IdpRetentionDurationAttrTypes,
	},
	"retention_durations": types.ListType{
		ElemType: types.ObjectType{
			AttrTypes: IdpColumnRetentionDurationAttrTypes,
		},
	},
}

var IdpColumnRetentionDurationsResponseAttributes = map[string]schema.Attribute{
	"max_duration": schema.SingleNestedAttribute{
		Attributes:          IdpRetentionDurationAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"retention_durations": schema.ListNestedAttribute{
		NestedObject: schema.NestedAttributeObject{
			Attributes: IdpColumnRetentionDurationAttributes,
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var IdpCreateAccessorRequestAttrTypes = map[string]attr.Type{
	"accessor": types.ObjectType{
		AttrTypes: UserstoreAccessorAttrTypes,
	},
}

var IdpCreateAccessorRequestAttributes = map[string]schema.Attribute{
	"accessor": schema.SingleNestedAttribute{
		Attributes:          UserstoreAccessorAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var IdpCreateColumnRequestAttrTypes = map[string]attr.Type{
	"column": types.ObjectType{
		AttrTypes: UserstoreColumnAttrTypes,
	},
}

var IdpCreateColumnRequestAttributes = map[string]schema.Attribute{
	"column": schema.SingleNestedAttribute{
		Attributes:          UserstoreColumnAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var IdpCreateDataTypeRequestAttrTypes = map[string]attr.Type{
	"data_type": types.ObjectType{
		AttrTypes: UserstoreColumnDataTypeAttrTypes,
	},
}

var IdpCreateDataTypeRequestAttributes = map[string]schema.Attribute{
	"data_type": schema.SingleNestedAttribute{
		Attributes:          UserstoreColumnDataTypeAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var IdpCreateMutatorRequestAttrTypes = map[string]attr.Type{
	"mutator": types.ObjectType{
		AttrTypes: UserstoreMutatorAttrTypes,
	},
}

var IdpCreateMutatorRequestAttributes = map[string]schema.Attribute{
	"mutator": schema.SingleNestedAttribute{
		Attributes:          UserstoreMutatorAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var IdpCreatePurposeRequestAttrTypes = map[string]attr.Type{
	"purpose": types.ObjectType{
		AttrTypes: UserstorePurposeAttrTypes,
	},
}

var IdpCreatePurposeRequestAttributes = map[string]schema.Attribute{
	"purpose": schema.SingleNestedAttribute{
		Attributes:          UserstorePurposeAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var IdpDurationUnitAttrTypes = map[string]attr.Type{}

var IdpDurationUnitAttributes = map[string]schema.Attribute{}

var IdpExecuteMutatorResponseAttrTypes = map[string]attr.Type{
	"user_ids": types.ListType{
		ElemType: types.StringType,
	},
}

var IdpExecuteMutatorResponseAttributes = map[string]schema.Attribute{
	"user_ids": schema.ListAttribute{
		ElementType:         types.StringType,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var IdpGetConsentedPurposesForUserRequestAttrTypes = map[string]attr.Type{
	"columns": types.ListType{
		ElemType: types.StringType,
	},
	"user_id": types.StringType,
}

var IdpGetConsentedPurposesForUserRequestAttributes = map[string]schema.Attribute{
	"columns": schema.ListAttribute{
		ElementType:         types.StringType,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"user_id": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var IdpGetConsentedPurposesForUserResponseAttrTypes = map[string]attr.Type{
	"data": types.ListType{
		ElemType: types.ObjectType{
			AttrTypes: IdpColumnConsentedPurposesAttrTypes,
		},
	},
}

var IdpGetConsentedPurposesForUserResponseAttributes = map[string]schema.Attribute{
	"data": schema.ListNestedAttribute{
		NestedObject: schema.NestedAttributeObject{
			Attributes: IdpColumnConsentedPurposesAttributes,
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var IdpRetentionDurationAttrTypes = map[string]attr.Type{
	"duration": types.Int64Type,
	"unit":     types.StringType,
}

var IdpRetentionDurationAttributes = map[string]schema.Attribute{
	"duration": schema.Int64Attribute{
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"unit": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.OneOf([]string{"day", "hour", "indefinite", "month", "week", "year"}...),
		},
		Computed:            true,
		Description:         "Valid values: `day`, `hour`, `indefinite`, `month`, `week`, `year`",
		MarkdownDescription: "Valid values: `day`, `hour`, `indefinite`, `month`, `week`, `year`",
		Optional:            true,
	},
}

var IdpUpdateColumnRetentionDurationRequestAttrTypes = map[string]attr.Type{
	"retention_duration": types.ObjectType{
		AttrTypes: IdpColumnRetentionDurationAttrTypes,
	},
}

var IdpUpdateColumnRetentionDurationRequestAttributes = map[string]schema.Attribute{
	"retention_duration": schema.SingleNestedAttribute{
		Attributes:          IdpColumnRetentionDurationAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var PaginationCursorAttrTypes = map[string]attr.Type{}

var PaginationCursorAttributes = map[string]schema.Attribute{}

var PolicyClientContextAttrTypes = map[string]attr.Type{}

var PolicyClientContextAttributes = map[string]schema.Attribute{}

var UUIDUuidAttrTypes = map[string]attr.Type{}

var UUIDUuidAttributes = map[string]schema.Attribute{}

var UserstoreAccessorAttrTypes = map[string]attr.Type{
	"access_policy": types.StringType,
	"columns": types.ListType{
		ElemType: types.ObjectType{
			AttrTypes: UserstoreColumnOutputConfigAttrTypes,
		},
	},
	"data_life_cycle_state": types.StringType,
	"description":           types.StringType,
	"id":                    types.StringType,
	"is_audit_logged":       types.BoolType,
	"name":                  types.StringType,
	"purposes": types.ListType{
		ElemType: types.StringType,
	},
	"selector_config": types.ObjectType{
		AttrTypes: UserstoreUserSelectorConfigAttrTypes,
	},
	"token_access_policy": types.StringType,
	"version":             types.Int64Type,
}

var UserstoreAccessorAttributes = map[string]schema.Attribute{
	"access_policy": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Description:         "",
		MarkdownDescription: "",
		Required:            true,
	},
	"columns": schema.ListNestedAttribute{
		NestedObject: schema.NestedAttributeObject{
			Attributes: UserstoreColumnOutputConfigAttributes,
		},
		Description:         "",
		MarkdownDescription: "",
		Required:            true,
	},
	"data_life_cycle_state": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.OneOf([]string{"", "live", "postdelete", "predelete", "softdeleted"}...),
		},
		Computed:            true,
		Description:         "Valid values: `live`, `postdelete`, `predelete`, `softdeleted`",
		MarkdownDescription: "Valid values: `live`, `postdelete`, `predelete`, `softdeleted`",
		Optional:            true,
	},
	"description": schema.StringAttribute{
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"id": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
		PlanModifiers: []planmodifier.String{
			stringplanmodifier.UseStateForUnknown(),
		},
	},
	"is_audit_logged": schema.BoolAttribute{
		Computed:            true,
		Description:         "Whether this accessor is audit logged each time it is executed.",
		MarkdownDescription: "Whether this accessor is audit logged each time it is executed.",
		Optional:            true,
	},
	"name": schema.StringAttribute{
		Description:         "",
		MarkdownDescription: "",
		Required:            true,
	},
	"purposes": schema.ListAttribute{
		ElementType:         types.StringType,
		Description:         "",
		MarkdownDescription: "",
		Required:            true,
	},
	"selector_config": schema.SingleNestedAttribute{
		Attributes:          UserstoreUserSelectorConfigAttributes,
		Description:         "",
		MarkdownDescription: "",
		Required:            true,
	},
	"token_access_policy": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"version": schema.Int64Attribute{
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		PlanModifiers: []planmodifier.Int64{
			planmodifiers.IncrementOnUpdate(),
		},
	},
}

var UserstoreColumnAttrTypes = map[string]attr.Type{
	"constraints": types.ObjectType{
		AttrTypes: UserstoreColumnConstraintsAttrTypes,
	},
	"data_type":     types.StringType,
	"default_value": types.StringType,
	"id":            types.StringType,
	"index_type":    types.StringType,
	"is_array":      types.BoolType,
	"name":          types.StringType,
	"type":          types.StringType,
}

var UserstoreColumnAttributes = map[string]schema.Attribute{
	"constraints": schema.SingleNestedAttribute{
		Attributes:          UserstoreColumnConstraintsAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"data_type": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"default_value": schema.StringAttribute{
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"id": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
		PlanModifiers: []planmodifier.String{
			stringplanmodifier.UseStateForUnknown(),
		},
	},
	"index_type": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.OneOf([]string{"indexed", "none", "unique"}...),
		},
		Description:         "Valid values: `indexed`, `none`, `unique`",
		MarkdownDescription: "Valid values: `indexed`, `none`, `unique`",
		Required:            true,
	},
	"is_array": schema.BoolAttribute{
		Description:         "",
		MarkdownDescription: "",
		PlanModifiers: []planmodifier.Bool{
			boolplanmodifier.RequiresReplace(),
		},
		Required: true,
	},
	"name": schema.StringAttribute{
		Description:         "",
		MarkdownDescription: "",
		Required:            true,
	},
	"type": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.OneOf([]string{"address", "birthdate", "boolean", "composite", "date", "e164_phonenumber", "email", "integer", "phonenumber", "ssn", "string", "timestamp", "uuid"}...),
		},
		Description:         "Valid values: `address`, `birthdate`, `boolean`, `composite`, `date`, `e164_phonenumber`, `email`, `integer`, `phonenumber`, `ssn`, `string`, `timestamp`, `uuid`",
		MarkdownDescription: "Valid values: `address`, `birthdate`, `boolean`, `composite`, `date`, `e164_phonenumber`, `email`, `integer`, `phonenumber`, `ssn`, `string`, `timestamp`, `uuid`",
		PlanModifiers: []planmodifier.String{
			stringplanmodifier.RequiresReplace(),
		},
		Required: true,
	},
}

var UserstoreColumnConstraintsAttrTypes = map[string]attr.Type{
	"fields": types.ListType{
		ElemType: types.ObjectType{
			AttrTypes: UserstoreColumnFieldAttrTypes,
		},
	},
	"immutable_required": types.BoolType,
	"partial_updates":    types.BoolType,
	"unique_id_required": types.BoolType,
	"unique_required":    types.BoolType,
}

var UserstoreColumnConstraintsAttributes = map[string]schema.Attribute{
	"fields": schema.ListNestedAttribute{
		NestedObject: schema.NestedAttributeObject{
			Attributes: UserstoreColumnFieldAttributes,
		},
		Computed:            true,
		Description:         "The set of fields associated with a column of type composite. Fields cannot be specified if the column type is not composite.",
		MarkdownDescription: "The set of fields associated with a column of type composite. Fields cannot be specified if the column type is not composite.",
		Optional:            true,
	},
	"immutable_required": schema.BoolAttribute{
		Computed:            true,
		Description:         "Can be enabled when unique_id_required is enabled. If true, values for the associated column cannot be modified, but can be added or removed.",
		MarkdownDescription: "Can be enabled when unique_id_required is enabled. If true, values for the associated column cannot be modified, but can be added or removed.",
		Optional:            true,
	},
	"partial_updates": schema.BoolAttribute{
		Computed:            true,
		Description:         "Can be enabled for array columns that have UniqueRequired or UniqueIDRequired enabled. When enabled, a mutation request will update the specified subset of values for the associated column.",
		MarkdownDescription: "Can be enabled for array columns that have UniqueRequired or UniqueIDRequired enabled. When enabled, a mutation request will update the specified subset of values for the associated column.",
		Optional:            true,
	},
	"unique_id_required": schema.BoolAttribute{
		Computed:            true,
		Description:         "Can be enabled for column type composite or address. If true, each value for the associated column must have a unique string ID, which can either be provided or generated by backend.",
		MarkdownDescription: "Can be enabled for column type composite or address. If true, each value for the associated column must have a unique string ID, which can either be provided or generated by backend.",
		Optional:            true,
	},
	"unique_required": schema.BoolAttribute{
		Computed:            true,
		Description:         "If true, each value for the associated column must be unique for the user. This is primarily useful for array columns.",
		MarkdownDescription: "If true, each value for the associated column must be unique for the user. This is primarily useful for array columns.",
		Optional:            true,
	},
}

var UserstoreColumnDataTypeAttrTypes = map[string]attr.Type{
	"composite_attributes": types.ObjectType{
		AttrTypes: UserstoreCompositeAttributesAttrTypes,
	},
	"description":             types.StringType,
	"id":                      types.StringType,
	"is_composite_field_type": types.BoolType,
	"is_native":               types.BoolType,
	"name":                    types.StringType,
}

var UserstoreColumnDataTypeAttributes = map[string]schema.Attribute{
	"composite_attributes": schema.SingleNestedAttribute{
		Attributes:          UserstoreCompositeAttributesAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"description": schema.StringAttribute{
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"id": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
		PlanModifiers: []planmodifier.String{
			stringplanmodifier.UseStateForUnknown(),
		},
	},
	"is_composite_field_type": schema.BoolAttribute{
		Computed:            true,
		Description:         "Whether the data type can be used for a composite field.",
		MarkdownDescription: "Whether the data type can be used for a composite field.",
		Optional:            true,
	},
	"is_native": schema.BoolAttribute{
		Computed:            true,
		Description:         "Whether this is a native non-editable data type.",
		MarkdownDescription: "Whether this is a native non-editable data type.",
		Optional:            true,
	},
	"name": schema.StringAttribute{
		Description:         "",
		MarkdownDescription: "",
		Required:            true,
	},
}

var UserstoreColumnFieldAttrTypes = map[string]attr.Type{
	"camel_case_name":       types.StringType,
	"ignore_for_uniqueness": types.BoolType,
	"name":                  types.StringType,
	"required":              types.BoolType,
	"struct_name":           types.StringType,
	"type":                  types.StringType,
}

var UserstoreColumnFieldAttributes = map[string]schema.Attribute{
	"camel_case_name": schema.StringAttribute{
		Computed:            true,
		Description:         "Read-only camel-case version of field name, with underscores stripped out. (ex. IDField1)",
		MarkdownDescription: "Read-only camel-case version of field name, with underscores stripped out. (ex. IDField1)",
		Optional:            true,
	},
	"ignore_for_uniqueness": schema.BoolAttribute{
		Computed:            true,
		Description:         "If true, field value will be ignored when comparing two composite value for a uniqueness check.",
		MarkdownDescription: "If true, field value will be ignored when comparing two composite value for a uniqueness check.",
		Optional:            true,
	},
	"name": schema.StringAttribute{
		Description:         "Each part of name must be capitalized or all-caps, separated by underscores. Names may contain alphanumeric characters, and the first part must start with a letter, while other parts may start with a number. (ex. ID_Field_1)",
		MarkdownDescription: "Each part of name must be capitalized or all-caps, separated by underscores. Names may contain alphanumeric characters, and the first part must start with a letter, while other parts may start with a number. (ex. ID_Field_1)",
		Required:            true,
	},
	"required": schema.BoolAttribute{
		Computed:            true,
		Description:         "Whether a value must be specified for the field.",
		MarkdownDescription: "Whether a value must be specified for the field.",
		Optional:            true,
	},
	"struct_name": schema.StringAttribute{
		Computed:            true,
		Description:         "Read-only snake-case version of field name, with all letters lowercase. (ex. id_field_1)",
		MarkdownDescription: "Read-only snake-case version of field name, with all letters lowercase. (ex. id_field_1)",
		Optional:            true,
	},
	"type": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.OneOf([]string{"address", "birthdate", "boolean", "composite", "date", "e164_phonenumber", "email", "integer", "phonenumber", "ssn", "string", "timestamp", "uuid"}...),
		},
		Description:         "Valid values: `address`, `birthdate`, `boolean`, `composite`, `date`, `e164_phonenumber`, `email`, `integer`, `phonenumber`, `ssn`, `string`, `timestamp`, `uuid`",
		MarkdownDescription: "Valid values: `address`, `birthdate`, `boolean`, `composite`, `date`, `e164_phonenumber`, `email`, `integer`, `phonenumber`, `ssn`, `string`, `timestamp`, `uuid`",
		Required:            true,
	},
}

var UserstoreColumnIndexTypeAttrTypes = map[string]attr.Type{}

var UserstoreColumnIndexTypeAttributes = map[string]schema.Attribute{}

var UserstoreColumnInputConfigAttrTypes = map[string]attr.Type{
	"column":     types.StringType,
	"normalizer": types.StringType,
	"validator":  types.StringType,
}

var UserstoreColumnInputConfigAttributes = map[string]schema.Attribute{
	"column": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"normalizer": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"validator": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreColumnOutputConfigAttrTypes = map[string]attr.Type{
	"column":      types.StringType,
	"transformer": types.StringType,
}

var UserstoreColumnOutputConfigAttributes = map[string]schema.Attribute{
	"column": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"transformer": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreCompositeAttributesAttrTypes = map[string]attr.Type{
	"fields": types.ListType{
		ElemType: types.ObjectType{
			AttrTypes: UserstoreCompositeFieldAttrTypes,
		},
	},
	"include_id": types.BoolType,
}

var UserstoreCompositeAttributesAttributes = map[string]schema.Attribute{
	"fields": schema.ListNestedAttribute{
		NestedObject: schema.NestedAttributeObject{
			Attributes: UserstoreCompositeFieldAttributes,
		},
		Computed:            true,
		Description:         "The set of fields associated with a composite data type.",
		MarkdownDescription: "The set of fields associated with a composite data type.",
		Optional:            true,
	},
	"include_id": schema.BoolAttribute{
		Computed:            true,
		Description:         "Whether the composite data type must include an id field.",
		MarkdownDescription: "Whether the composite data type must include an id field.",
		Optional:            true,
	},
}

var UserstoreCompositeFieldAttrTypes = map[string]attr.Type{
	"camel_case_name":       types.StringType,
	"data_type":             types.StringType,
	"ignore_for_uniqueness": types.BoolType,
	"name":                  types.StringType,
	"required":              types.BoolType,
	"struct_name":           types.StringType,
}

var UserstoreCompositeFieldAttributes = map[string]schema.Attribute{
	"camel_case_name": schema.StringAttribute{
		Computed:            true,
		Description:         "Read-only camel-case version of field name, with underscores stripped out. (ex. IDField1)",
		MarkdownDescription: "Read-only camel-case version of field name, with underscores stripped out. (ex. IDField1)",
		Optional:            true,
	},
	"data_type": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"ignore_for_uniqueness": schema.BoolAttribute{
		Computed:            true,
		Description:         "If true, field value will be ignored when comparing two composite values for a uniqueness check.",
		MarkdownDescription: "If true, field value will be ignored when comparing two composite values for a uniqueness check.",
		Optional:            true,
	},
	"name": schema.StringAttribute{
		Description:         "Each part of name must be capitalized or all-caps, separated by underscores. Names may contain alphanumeric characters, and the first part must start with a letter, while other parts may start with a number. (ex. ID_Field_1)",
		MarkdownDescription: "Each part of name must be capitalized or all-caps, separated by underscores. Names may contain alphanumeric characters, and the first part must start with a letter, while other parts may start with a number. (ex. ID_Field_1)",
		Required:            true,
	},
	"required": schema.BoolAttribute{
		Computed:            true,
		Description:         "Whether a value must be specified for the field.",
		MarkdownDescription: "Whether a value must be specified for the field.",
		Optional:            true,
	},
	"struct_name": schema.StringAttribute{
		Computed:            true,
		Description:         "Read-only snake-case version of field name, with all letters lowercase. (ex. id_field_1)",
		MarkdownDescription: "Read-only snake-case version of field name, with all letters lowercase. (ex. id_field_1)",
		Optional:            true,
	},
}

var UserstoreDataLifeCycleStateAttrTypes = map[string]attr.Type{}

var UserstoreDataLifeCycleStateAttributes = map[string]schema.Attribute{}

var UserstoreDataTypeAttrTypes = map[string]attr.Type{}

var UserstoreDataTypeAttributes = map[string]schema.Attribute{}

var UserstoreMutatorAttrTypes = map[string]attr.Type{
	"access_policy": types.StringType,
	"columns": types.ListType{
		ElemType: types.ObjectType{
			AttrTypes: UserstoreColumnInputConfigAttrTypes,
		},
	},
	"description": types.StringType,
	"id":          types.StringType,
	"name":        types.StringType,
	"selector_config": types.ObjectType{
		AttrTypes: UserstoreUserSelectorConfigAttrTypes,
	},
	"version": types.Int64Type,
}

var UserstoreMutatorAttributes = map[string]schema.Attribute{
	"access_policy": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Description:         "",
		MarkdownDescription: "",
		Required:            true,
	},
	"columns": schema.ListNestedAttribute{
		NestedObject: schema.NestedAttributeObject{
			Attributes: UserstoreColumnInputConfigAttributes,
		},
		Description:         "",
		MarkdownDescription: "",
		Required:            true,
	},
	"description": schema.StringAttribute{
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"id": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
		PlanModifiers: []planmodifier.String{
			stringplanmodifier.UseStateForUnknown(),
		},
	},
	"name": schema.StringAttribute{
		Description:         "",
		MarkdownDescription: "",
		Required:            true,
	},
	"selector_config": schema.SingleNestedAttribute{
		Attributes:          UserstoreUserSelectorConfigAttributes,
		Description:         "",
		MarkdownDescription: "",
		Required:            true,
	},
	"version": schema.Int64Attribute{
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		PlanModifiers: []planmodifier.Int64{
			planmodifiers.IncrementOnUpdate(),
		},
	},
}

var UserstorePurposeAttrTypes = map[string]attr.Type{
	"description": types.StringType,
	"id":          types.StringType,
	"name":        types.StringType,
}

var UserstorePurposeAttributes = map[string]schema.Attribute{
	"description": schema.StringAttribute{
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
	"id": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
		PlanModifiers: []planmodifier.String{
			stringplanmodifier.UseStateForUnknown(),
		},
	},
	"name": schema.StringAttribute{
		Description:         "",
		MarkdownDescription: "",
		Required:            true,
	},
}

var UserstoreResourceIDAttrTypes = map[string]attr.Type{
	"id":   types.StringType,
	"name": types.StringType,
}

var UserstoreResourceIDAttributes = map[string]schema.Attribute{
	"id": schema.StringAttribute{
		Validators: []validator.String{
			stringvalidator.RegexMatches(
				regexp.MustCompile("(?i)^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$"),
				"invalid UUID format",
			),
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
		PlanModifiers: []planmodifier.String{
			stringplanmodifier.UseStateForUnknown(),
		},
	},
	"name": schema.StringAttribute{
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUpdateAccessorRequestAttrTypes = map[string]attr.Type{
	"accessor": types.ObjectType{
		AttrTypes: UserstoreAccessorAttrTypes,
	},
}

var UserstoreUpdateAccessorRequestAttributes = map[string]schema.Attribute{
	"accessor": schema.SingleNestedAttribute{
		Attributes:          UserstoreAccessorAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUpdateColumnRequestAttrTypes = map[string]attr.Type{
	"column": types.ObjectType{
		AttrTypes: UserstoreColumnAttrTypes,
	},
}

var UserstoreUpdateColumnRequestAttributes = map[string]schema.Attribute{
	"column": schema.SingleNestedAttribute{
		Attributes:          UserstoreColumnAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUpdateColumnRetentionDurationRequestAttrTypes = map[string]attr.Type{
	"retention_duration": types.ObjectType{
		AttrTypes: IdpColumnRetentionDurationAttrTypes,
	},
}

var UserstoreUpdateColumnRetentionDurationRequestAttributes = map[string]schema.Attribute{
	"retention_duration": schema.SingleNestedAttribute{
		Attributes:          IdpColumnRetentionDurationAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUpdateColumnRetentionDurationRequestType2AttrTypes = map[string]attr.Type{
	"retention_duration": types.ObjectType{
		AttrTypes: IdpColumnRetentionDurationAttrTypes,
	},
}

var UserstoreUpdateColumnRetentionDurationRequestType2Attributes = map[string]schema.Attribute{
	"retention_duration": schema.SingleNestedAttribute{
		Attributes:          IdpColumnRetentionDurationAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUpdateColumnRetentionDurationRequestType3AttrTypes = map[string]attr.Type{
	"retention_duration": types.ObjectType{
		AttrTypes: IdpColumnRetentionDurationAttrTypes,
	},
}

var UserstoreUpdateColumnRetentionDurationRequestType3Attributes = map[string]schema.Attribute{
	"retention_duration": schema.SingleNestedAttribute{
		Attributes:          IdpColumnRetentionDurationAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUpdateColumnRetentionDurationRequestType4AttrTypes = map[string]attr.Type{
	"retention_duration": types.ObjectType{
		AttrTypes: IdpColumnRetentionDurationAttrTypes,
	},
}

var UserstoreUpdateColumnRetentionDurationRequestType4Attributes = map[string]schema.Attribute{
	"retention_duration": schema.SingleNestedAttribute{
		Attributes:          IdpColumnRetentionDurationAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUpdateColumnRetentionDurationRequestType5AttrTypes = map[string]attr.Type{
	"retention_duration": types.ObjectType{
		AttrTypes: IdpColumnRetentionDurationAttrTypes,
	},
}

var UserstoreUpdateColumnRetentionDurationRequestType5Attributes = map[string]schema.Attribute{
	"retention_duration": schema.SingleNestedAttribute{
		Attributes:          IdpColumnRetentionDurationAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUpdateColumnRetentionDurationRequestType6AttrTypes = map[string]attr.Type{
	"retention_duration": types.ObjectType{
		AttrTypes: IdpColumnRetentionDurationAttrTypes,
	},
}

var UserstoreUpdateColumnRetentionDurationRequestType6Attributes = map[string]schema.Attribute{
	"retention_duration": schema.SingleNestedAttribute{
		Attributes:          IdpColumnRetentionDurationAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUpdateColumnRetentionDurationRequestType7AttrTypes = map[string]attr.Type{
	"retention_duration": types.ObjectType{
		AttrTypes: IdpColumnRetentionDurationAttrTypes,
	},
}

var UserstoreUpdateColumnRetentionDurationRequestType7Attributes = map[string]schema.Attribute{
	"retention_duration": schema.SingleNestedAttribute{
		Attributes:          IdpColumnRetentionDurationAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUpdateColumnRetentionDurationRequestType8AttrTypes = map[string]attr.Type{
	"retention_duration": types.ObjectType{
		AttrTypes: IdpColumnRetentionDurationAttrTypes,
	},
}

var UserstoreUpdateColumnRetentionDurationRequestType8Attributes = map[string]schema.Attribute{
	"retention_duration": schema.SingleNestedAttribute{
		Attributes:          IdpColumnRetentionDurationAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUpdateColumnRetentionDurationsRequestAttrTypes = map[string]attr.Type{
	"retention_durations": types.ListType{
		ElemType: types.ObjectType{
			AttrTypes: IdpColumnRetentionDurationAttrTypes,
		},
	},
}

var UserstoreUpdateColumnRetentionDurationsRequestAttributes = map[string]schema.Attribute{
	"retention_durations": schema.ListNestedAttribute{
		NestedObject: schema.NestedAttributeObject{
			Attributes: IdpColumnRetentionDurationAttributes,
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUpdateColumnRetentionDurationsRequestType2AttrTypes = map[string]attr.Type{
	"retention_durations": types.ListType{
		ElemType: types.ObjectType{
			AttrTypes: IdpColumnRetentionDurationAttrTypes,
		},
	},
}

var UserstoreUpdateColumnRetentionDurationsRequestType2Attributes = map[string]schema.Attribute{
	"retention_durations": schema.ListNestedAttribute{
		NestedObject: schema.NestedAttributeObject{
			Attributes: IdpColumnRetentionDurationAttributes,
		},
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUpdateDataTypeRequestAttrTypes = map[string]attr.Type{
	"data_type": types.ObjectType{
		AttrTypes: UserstoreColumnDataTypeAttrTypes,
	},
}

var UserstoreUpdateDataTypeRequestAttributes = map[string]schema.Attribute{
	"data_type": schema.SingleNestedAttribute{
		Attributes:          UserstoreColumnDataTypeAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUpdateMutatorRequestAttrTypes = map[string]attr.Type{
	"mutator": types.ObjectType{
		AttrTypes: UserstoreMutatorAttrTypes,
	},
}

var UserstoreUpdateMutatorRequestAttributes = map[string]schema.Attribute{
	"mutator": schema.SingleNestedAttribute{
		Attributes:          UserstoreMutatorAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUpdatePurposeRequestAttrTypes = map[string]attr.Type{
	"purpose": types.ObjectType{
		AttrTypes: UserstorePurposeAttrTypes,
	},
}

var UserstoreUpdatePurposeRequestAttributes = map[string]schema.Attribute{
	"purpose": schema.SingleNestedAttribute{
		Attributes:          UserstorePurposeAttributes,
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUserSelectorConfigAttrTypes = map[string]attr.Type{
	"where_clause": types.StringType,
}

var UserstoreUserSelectorConfigAttributes = map[string]schema.Attribute{
	"where_clause": schema.StringAttribute{
		Computed:            true,
		Description:         "",
		MarkdownDescription: "",
		Optional:            true,
	},
}

var UserstoreUserSelectorValuesAttrTypes = map[string]attr.Type{}

var UserstoreUserSelectorValuesAttributes = map[string]schema.Attribute{}