"""
            ),
        ] = None,
        generate_unique_id_function: Annotated[
            Callable[[routing.APIRoute], str],
            Doc(
                """
                Customize the function used to generate unique IDs for the *path
                operations* shown in the generated OpenAPI.

// PrimaryKey returns the index is primary key or not.
func (idx Index) PrimaryKey() (isPrimaryKey bool, ok bool) {
	return idx.PrimaryKeyValue.Bool, idx.PrimaryKeyValue.Valid
}

// Unique returns whether the index is unique or not.
func (idx Index) Unique() (unique bool, ok bool) {
	return idx.UniqueValue.Bool, idx.UniqueValue.Valid
}

// Option return the optional attribute of the index
func (idx Index) Option() string {

							return
						}
						subName = composite
					}
					name = field.Schema.namer.IndexName(
						field.Schema.Table, subName)
				}

				if (k == "UNIQUEINDEX") || settings["UNIQUE"] != "" {
					settings["CLASS"] = "UNIQUE"
				}

				priority, err := strconv.Atoi(settings["PRIORITY"])
				if err != nil {
					priority = 10
				}

				indexes = append(indexes, Index{
					Name:    name,

func (ct ColumnType) Nullable() (nullable bool, ok bool) {
	if ct.NullableValue.Valid {
		return ct.NullableValue.Bool, true
	}
	return ct.SQLColumnType.Nullable()
}

// Unique reports whether the column may be unique.
func (ct ColumnType) Unique() (unique bool, ok bool) {
	return ct.UniqueValue.Bool, ct.UniqueValue.Valid
}

// ScanType returns a Go type suitable for scanning into using Rows.Scan.

  std::unique_ptr<ParallelTensor> CopyToParallelDevice(TFE_Context* context,
                                                       TFE_TensorHandle* tensor,
                                                       TF_Status* status) const;

  // Construct a parallel tensor consisting of the scalar values from `values`.
  template <typename DataType>
  std::unique_ptr<ParallelTensor> ScalarsFromSequence(

			[in] uint16_t level,
			[out,switch_is(level),unique] LsarPolicyInfo *info);

	[op(0x0f)]
	int LsarLookupSids([in] policy_handle *handle,
			[in] LsarSidArray *sids,
			[out,unique] LsarRefDomainList *domains,
			[in,out] LsarTransNameArray *names,
			[in] uint16_t level,
			[in,out] uint32_t *count);

	[op(0x2c)]
	int LsarOpenPolicy2([in,string,unique] wchar_t *system_name,

			[in] uint16_t level,
			[out,switch_is(level),unique] LsarPolicyInfo *info);

	[op(0x0f)]
	int LsarLookupSids([in] policy_handle *handle,
			[in] LsarSidArray *sids,
			[out,unique] LsarRefDomainList *domains,
			[in,out] LsarTransNameArray *names,
			[in] uint16_t level,
			[in,out] uint32_t *count);

	[op(0x2c)]
	int LsarOpenPolicy2([in,string,unique] wchar_t *system_name,

   *
   * <p>Because a {@code SetMultimap} has unique values for a given key, this method returns a
   * {@link Set}, instead of the {@link Collection} specified in the {@link Multimap} interface.
   */
  @Override
  public Set<V> get(@ParametricNullness K key) {
    return (Set<V>) super.get(key);
  }

  /**
   * {@inheritDoc}
   *
   * <p>Because a {@code SetMultimap} has unique values for a given key, this method returns a

class OpDeleter {
 public:
  void operator()(TFE_Op* to_delete) const { TFE_DeleteOp(to_delete); }
};

using OpPtr = std::unique_ptr<TFE_Op, OpDeleter>;

class StatusDeleter {
 public:
  void operator()(TF_Status* to_delete) const { TF_DeleteStatus(to_delete); }
};

using StatusPtr = std::unique_ptr<TF_Status, StatusDeleter>;

class ExecutorDeleter {
 public:
  void operator()(TFE_Executor* to_delete) const {

    }

    /**
     * Create a remote deployment repository.
     *
     * @param id            the unique identifier of the repository
     * @param url           the URL of the repository
     * @param layout        the layout of the repository
     * @param uniqueVersion whether to assign each snapshot a unique version
     */