}

func (c createG[T]) Omit(columns ...string) CreateInterface[T] {
	return createG[T]{c.with(func(db *DB) *DB {
		return db.Omit(columns...)
	})}
}

func (c createG[T]) Set(assignments ...clause.Assigner) SetCreateOrUpdateInterface[T] {
	return c.processSet(assignments...)
}

func (c createG[T]) Create(ctx context.Context, r *T) error {
	return c.g.apply(ctx).Create(r).Error
}

				if i, ok := value.(BeforeCreateInterface); ok {
					called = true
					db.AddError(i.BeforeCreate(tx))
				}
			}
			return called
		})
	}
}

// Create create hook
func Create(config *Config) func(db *gorm.DB) {
	supportReturning := utils.Contains(config.CreateClauses, "RETURNING")

	return func(db *gorm.DB) {
		if db.Error != nil {
			return
		}

                created = true;
            }
            return created;
        } catch (final Exception e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to create suggest index: index={}", index, e);
            }
            throw new SuggesterException("Failed to create suggest index: " + index, e);
        }
    }

    /**

 *       verified or created.
 *   <li>If a new edge needs to be created, the outgoing edges of the acquired locks are traversed
 *       to check for a cycle that reaches the lock to be acquired. If no cycle is detected, a new
 *       "safe" edge is created.
 *   <li>If a cycle is detected, an "unsafe" (cyclic) edge is created to represent a potential

            }
            boolean created = false;
            try (ImageInputStream input = ImageIO.createImageInputStream(responseData.getResponseBody())) {
                switch (saveImage(input, outputFile)) {
                case OK:
                    created = true;
                    break;
                case FAILED:

                throw new CIFSException("Failed to create any channels for session " + sessionId);
            }

            log.info("Created {} channels for session {}", channelGroup.getChannelCount(), sessionId);
            return channelGroup;

        } catch (Exception e) {
            sessionChannels.remove(sessionId);
            throw new CIFSException("Failed to create channels for session " + sessionId, e);
        }

    /**
     * Creates a new role item.
     *
     * @param form the create form containing the new item data
     * @return HTML response redirecting to the list page after creation
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse create(final CreateForm form) {
        verifyCrudMode(form.crudMode, CrudMode.CREATE, this::asListHtml);

  /**
   * Creates a new min-max priority queue with default settings: natural order, no maximum size, no
   * initial contents, and an initial expected size of 11.
   */
  public static <E extends Comparable<E>> MinMaxPriorityQueue<E> create() {
    return new Builder<Comparable<E>>(Ordering.natural()).create();
  }

  /**

                }))
                .status(ApiResult.Status.OK)
                .result());
    }

    /**
     * Creates a new scheduler setting.
     *
     * @param body the scheduler data to create
     * @return JSON response containing the created scheduler setting ID
     */
    // POST /api/admin/scheduler/setting
    @Execute

 * </ul>
 *
 * <p>Protected Methods:
 * <ul>
 * <li>{@link #createArraySettingsIndexName(String)}: Creates the name for the array settings index.</li>
 * <li>{@link #createId(String, Object)}: Creates a unique ID for a key-value pair using Base64 encoding.</li>
 * <li>{@link #getFromArrayIndex(String, String, String)}: Retrieves an array of maps from the index based on the key.</li>